diff options
author | Jaakko Keränen <jaakko.keranen@iki.fi> | 2020-07-21 15:06:52 +0300 |
---|---|---|
committer | Jaakko Keränen <jaakko.keranen@iki.fi> | 2020-07-21 15:07:38 +0300 |
commit | d773b499e595a43b9b1ae449262dcf13cabf2d02 (patch) | |
tree | b1baeb12025a04f8316636b5d0ab18e30ceedb2c /src |
Initial commit
Borrowing the app skeleton from Bitwise Harmony.
Diffstat (limited to 'src')
-rw-r--r-- | src/app.c | 300 | ||||
-rw-r--r-- | src/app.h | 29 | ||||
-rw-r--r-- | src/main.c | 25 | ||||
-rw-r--r-- | src/stb_image.h | 7656 | ||||
-rw-r--r-- | src/stb_truetype.h | 5011 | ||||
-rw-r--r-- | src/ui/color.c | 27 | ||||
-rw-r--r-- | src/ui/color.h | 48 | ||||
-rw-r--r-- | src/ui/command.c | 89 | ||||
-rw-r--r-- | src/ui/command.h | 16 | ||||
-rw-r--r-- | src/ui/inputwidget.c | 280 | ||||
-rw-r--r-- | src/ui/inputwidget.h | 20 | ||||
-rw-r--r-- | src/ui/labelwidget.c | 281 | ||||
-rw-r--r-- | src/ui/labelwidget.h | 22 | ||||
-rw-r--r-- | src/ui/macos.h | 9 | ||||
-rw-r--r-- | src/ui/macos.m | 434 | ||||
-rw-r--r-- | src/ui/metrics.c | 16 | ||||
-rw-r--r-- | src/ui/metrics.h | 9 | ||||
-rw-r--r-- | src/ui/paint.c | 58 | ||||
-rw-r--r-- | src/ui/paint.h | 33 | ||||
-rw-r--r-- | src/ui/text.c | 533 | ||||
-rw-r--r-- | src/ui/text.h | 52 | ||||
-rw-r--r-- | src/ui/util.c | 604 | ||||
-rw-r--r-- | src/ui/util.h | 110 | ||||
-rw-r--r-- | src/ui/widget.c | 618 | ||||
-rw-r--r-- | src/ui/widget.h | 131 | ||||
-rw-r--r-- | src/ui/window.c | 441 | ||||
-rw-r--r-- | src/ui/window.h | 34 | ||||
-rw-r--r-- | src/win32.c | 18 | ||||
-rw-r--r-- | src/win32.h | 4 |
29 files changed, 16908 insertions, 0 deletions
diff --git a/src/app.c b/src/app.c new file mode 100644 index 00000000..019308be --- /dev/null +++ b/src/app.c | |||
@@ -0,0 +1,300 @@ | |||
1 | #include "app.h" | ||
2 | #include "ui/command.h" | ||
3 | #include "ui/window.h" | ||
4 | #include "ui/inputwidget.h" | ||
5 | #include "ui/labelwidget.h" | ||
6 | #include "ui/util.h" | ||
7 | #include "ui/text.h" | ||
8 | #include "ui/color.h" | ||
9 | |||
10 | #include <the_Foundation/commandline.h> | ||
11 | #include <the_Foundation/file.h> | ||
12 | #include <the_Foundation/fileinfo.h> | ||
13 | #include <the_Foundation/path.h> | ||
14 | #include <the_Foundation/process.h> | ||
15 | #include <the_Foundation/sortedarray.h> | ||
16 | #include <the_Foundation/time.h> | ||
17 | #include <SDL_events.h> | ||
18 | #include <SDL_render.h> | ||
19 | #include <SDL_video.h> | ||
20 | |||
21 | #include <stdio.h> | ||
22 | #include <stdarg.h> | ||
23 | #include <errno.h> | ||
24 | |||
25 | #if defined (iPlatformApple) && !defined (iPlatformIOS) | ||
26 | # include "ui/macos.h" | ||
27 | #endif | ||
28 | |||
29 | iDeclareType(App) | ||
30 | |||
31 | #if defined (iPlatformApple) | ||
32 | static const char *dataDir_App_ = "~/Library/Application Support/fi.skyjake.Lagrange"; | ||
33 | #endif | ||
34 | #if defined (iPlatformMsys) | ||
35 | static const char *dataDir_App_ = "~/AppData/Roaming/fi.skyjake.Lagrange"; | ||
36 | #endif | ||
37 | #if defined (iPlatformLinux) | ||
38 | static const char *dataDir_App_ = "~/.config/lagrange"; | ||
39 | #endif | ||
40 | static const char *prefsFileName_App_ = "prefs.cfg"; | ||
41 | |||
42 | struct Impl_App { | ||
43 | iCommandLine args; | ||
44 | iBool running; | ||
45 | iWindow * window; | ||
46 | iSortedArray tickers; | ||
47 | /* Preferences: */ | ||
48 | iBool retainWindowSize; | ||
49 | float uiScale; | ||
50 | }; | ||
51 | |||
52 | static iApp app_; | ||
53 | |||
54 | iDeclareType(Ticker) | ||
55 | |||
56 | struct Impl_Ticker { | ||
57 | iAny *context; | ||
58 | void (*callback)(iAny *); | ||
59 | }; | ||
60 | |||
61 | static int cmp_Ticker_(const void *a, const void *b) { | ||
62 | const iTicker *elems[2] = { a, b }; | ||
63 | return iCmp(elems[0]->context, elems[1]->context); | ||
64 | } | ||
65 | |||
66 | const iString *dateStr_(const iDate *date) { | ||
67 | return collectNewFormat_String("%d-%02d-%02d %02d:%02d:%02d", | ||
68 | date->year, | ||
69 | date->month, | ||
70 | date->day, | ||
71 | date->hour, | ||
72 | date->minute, | ||
73 | date->second); | ||
74 | } | ||
75 | |||
76 | static iString *serializePrefs_App_(const iApp *d) { | ||
77 | iString *str = new_String(); | ||
78 | iWindow *win = get_Window(); | ||
79 | if (d->retainWindowSize) { | ||
80 | int w, h, x, y; | ||
81 | SDL_GetWindowSize(d->window->win, &w, &h); | ||
82 | SDL_GetWindowPosition(d->window->win, &x, &y); | ||
83 | appendFormat_String(str, "restorewindow width:%d height:%d coord:%d %d\n", w, h, x, y); | ||
84 | } | ||
85 | appendFormat_String(str, "uiscale arg:%f\n", uiScale_Window(d->window)); | ||
86 | return str; | ||
87 | } | ||
88 | |||
89 | static const iString *prefsFileName_(void) { | ||
90 | return collect_String(concatCStr_Path(&iStringLiteral(dataDir_App_), prefsFileName_App_)); | ||
91 | } | ||
92 | |||
93 | static void loadPrefs_App_(iApp *d) { | ||
94 | iUnused(d); | ||
95 | /* Create the data dir if it doesn't exist yet. */ | ||
96 | makeDirs_Path(collectNewCStr_String(dataDir_App_)); | ||
97 | iFile *f = new_File(prefsFileName_()); | ||
98 | if (open_File(f, readOnly_FileMode | text_FileMode)) { | ||
99 | iString *str = readString_File(f); | ||
100 | const iRangecc src = range_String(str); | ||
101 | iRangecc line = iNullRange; | ||
102 | while (nextSplit_Rangecc(&src, "\n", &line)) { | ||
103 | iString cmd; | ||
104 | initRange_String(&cmd, &line); | ||
105 | if (equal_Command(cstr_String(&cmd), "uiscale")) { | ||
106 | /* Must be handled before the window is created. */ | ||
107 | setUiScale_Window(get_Window(), argf_Command(cstr_String(&cmd))); | ||
108 | } | ||
109 | else { | ||
110 | postCommandString_App(&cmd); | ||
111 | } | ||
112 | deinit_String(&cmd); | ||
113 | } | ||
114 | delete_String(str); | ||
115 | } | ||
116 | else { | ||
117 | /* default preference values */ | ||
118 | } | ||
119 | iRelease(f); | ||
120 | } | ||
121 | |||
122 | static void savePrefs_App_(const iApp *d) { | ||
123 | iString *cfg = serializePrefs_App_(d); | ||
124 | iFile *f = new_File(prefsFileName_()); | ||
125 | if (open_File(f, writeOnly_FileMode | text_FileMode)) { | ||
126 | write_File(f, &cfg->chars); | ||
127 | } | ||
128 | iRelease(f); | ||
129 | delete_String(cfg); | ||
130 | } | ||
131 | |||
132 | static void init_App_(iApp *d, int argc, char **argv) { | ||
133 | init_CommandLine(&d->args, argc, argv); | ||
134 | init_SortedArray(&d->tickers, sizeof(iTicker), cmp_Ticker_); | ||
135 | d->running = iFalse; | ||
136 | d->window = NULL; | ||
137 | d->retainWindowSize = iTrue; | ||
138 | loadPrefs_App_(d); | ||
139 | d->window = new_Window(); | ||
140 | /* Widget state init. */ { | ||
141 | } | ||
142 | } | ||
143 | |||
144 | static void deinit_App(iApp *d) { | ||
145 | savePrefs_App_(d); | ||
146 | deinit_SortedArray(&d->tickers); | ||
147 | delete_Window(d->window); | ||
148 | d->window = NULL; | ||
149 | deinit_CommandLine(&d->args); | ||
150 | } | ||
151 | |||
152 | const iString *execPath_App(void) { | ||
153 | return executablePath_CommandLine(&app_.args); | ||
154 | } | ||
155 | |||
156 | void processEvents_App(void) { | ||
157 | iApp *d = &app_; | ||
158 | SDL_Event ev; | ||
159 | while (SDL_PollEvent(&ev)) { | ||
160 | switch (ev.type) { | ||
161 | case SDL_QUIT: | ||
162 | // if (isModified_Song(d->song)) { | ||
163 | // save_App_(d, autosavePath_App_(d)); | ||
164 | // } | ||
165 | d->running = iFalse; | ||
166 | break; | ||
167 | case SDL_DROPFILE: | ||
168 | postCommandf_App("open url:file://%s", ev.drop.file); | ||
169 | break; | ||
170 | default: { | ||
171 | iBool wasUsed = processEvent_Window(d->window, &ev); | ||
172 | if (ev.type == SDL_USEREVENT && ev.user.code == command_UserEventCode) { | ||
173 | #if defined (iPlatformApple) && !defined (iPlatformIOS) | ||
174 | handleCommand_MacOS(command_UserEvent(&ev)); | ||
175 | #endif | ||
176 | if (isCommand_UserEvent(&ev, "metrics.changed")) { | ||
177 | arrange_Widget(d->window->root); | ||
178 | } | ||
179 | if (!wasUsed) { | ||
180 | /* No widget handled the command, so we'll do it. */ | ||
181 | handleCommand_App(ev.user.data1); | ||
182 | } | ||
183 | /* Allocated by postCommand_App(). */ | ||
184 | free(ev.user.data1); | ||
185 | } | ||
186 | break; | ||
187 | } | ||
188 | } | ||
189 | } | ||
190 | } | ||
191 | |||
192 | static void runTickers_App_(iApp *d) { | ||
193 | /* Tickers may add themselves again, so we'll run off a copy. */ | ||
194 | iSortedArray *pending = copy_SortedArray(&d->tickers); | ||
195 | clear_SortedArray(&d->tickers); | ||
196 | iConstForEach(Array, i, &pending->values) { | ||
197 | const iTicker *ticker = i.value; | ||
198 | if (ticker->callback) { | ||
199 | ticker->callback(ticker->context); | ||
200 | } | ||
201 | } | ||
202 | delete_SortedArray(pending); | ||
203 | } | ||
204 | |||
205 | static int run_App_(iApp *d) { | ||
206 | arrange_Widget(findWidget_App("root")); | ||
207 | d->running = iTrue; | ||
208 | SDL_EventState(SDL_DROPFILE, SDL_ENABLE); /* open files via drag'n'drop */ | ||
209 | while (d->running) { | ||
210 | runTickers_App_(d); | ||
211 | processEvents_App(); | ||
212 | destroyPending_Widget(); | ||
213 | refresh_App(); | ||
214 | } | ||
215 | return 0; | ||
216 | } | ||
217 | |||
218 | void refresh_App(void) { | ||
219 | iApp *d = &app_; | ||
220 | draw_Window(d->window); | ||
221 | recycle_Garbage(); | ||
222 | } | ||
223 | |||
224 | int run_App(int argc, char **argv) { | ||
225 | init_App_(&app_, argc, argv); | ||
226 | const int rc = run_App_(&app_); | ||
227 | deinit_App(&app_); | ||
228 | return rc; | ||
229 | } | ||
230 | |||
231 | void postCommand_App(const char *command) { | ||
232 | SDL_Event ev; | ||
233 | ev.user.type = SDL_USEREVENT; | ||
234 | ev.user.code = command_UserEventCode; | ||
235 | ev.user.windowID = get_Window() ? SDL_GetWindowID(get_Window()->win) : 0; | ||
236 | ev.user.data1 = strdup(command); | ||
237 | ev.user.data2 = NULL; | ||
238 | SDL_PushEvent(&ev); | ||
239 | printf("[command] %s\n", command); fflush(stdout); | ||
240 | } | ||
241 | |||
242 | void postCommandf_App(const char *command, ...) { | ||
243 | iBlock chars; | ||
244 | init_Block(&chars, 0); | ||
245 | va_list args; | ||
246 | va_start(args, command); | ||
247 | vprintf_Block(&chars, command, args); | ||
248 | va_end(args); | ||
249 | postCommand_App(cstr_Block(&chars)); | ||
250 | deinit_Block(&chars); | ||
251 | } | ||
252 | |||
253 | iAny *findWidget_App(const char *id) { | ||
254 | return findChild_Widget(app_.window->root, id); | ||
255 | } | ||
256 | |||
257 | void addTicker_App(void (*ticker)(iAny *), iAny *context) { | ||
258 | iApp *d = &app_; | ||
259 | insert_SortedArray(&d->tickers, &(iTicker){ context, ticker }); | ||
260 | } | ||
261 | |||
262 | static iBool handlePrefsCommands_(iWidget *d, const char *cmd) { | ||
263 | if (equal_Command(cmd, "prefs.dismiss") || equal_Command(cmd, "preferences")) { | ||
264 | setUiScale_Window(get_Window(), | ||
265 | toFloat_String(text_InputWidget(findChild_Widget(d, "prefs.uiscale")))); | ||
266 | destroy_Widget(d); | ||
267 | return iTrue; | ||
268 | } | ||
269 | return iFalse; | ||
270 | } | ||
271 | |||
272 | iBool handleCommand_App(const char *cmd) { | ||
273 | iApp *d = &app_; | ||
274 | iWidget *root = d->window->root; | ||
275 | if (equal_Command(cmd, "open")) { | ||
276 | } | ||
277 | else if (equal_Command(cmd, "quit")) { | ||
278 | SDL_Event ev; | ||
279 | ev.type = SDL_QUIT; | ||
280 | SDL_PushEvent(&ev); | ||
281 | } | ||
282 | else if (equal_Command(cmd, "preferences")) { | ||
283 | iWindow *win = get_Window(); | ||
284 | iWidget *dlg = makePreferences_Widget(); | ||
285 | setToggle_Widget(findChild_Widget(dlg, "prefs.retainwindow"), d->retainWindowSize); | ||
286 | setText_InputWidget(findChild_Widget(dlg, "prefs.uiscale"), | ||
287 | collectNewFormat_String("%g", uiScale_Window(get_Window()))); | ||
288 | setCommandHandler_Widget(dlg, handlePrefsCommands_); | ||
289 | } | ||
290 | else if (equal_Command(cmd, "restorewindow")) { | ||
291 | d->retainWindowSize = iTrue; | ||
292 | resize_Window(d->window, argLabel_Command(cmd, "width"), argLabel_Command(cmd, "height")); | ||
293 | const iInt2 pos = coord_Command(cmd); | ||
294 | SDL_SetWindowPosition(d->window->win, pos.x, pos.y); | ||
295 | } | ||
296 | else { | ||
297 | return iFalse; | ||
298 | } | ||
299 | return iTrue; | ||
300 | } | ||
diff --git a/src/app.h b/src/app.h new file mode 100644 index 00000000..2c877d00 --- /dev/null +++ b/src/app.h | |||
@@ -0,0 +1,29 @@ | |||
1 | #pragma once | ||
2 | |||
3 | /* Application core: event loop, base event processing, audio synth. */ | ||
4 | |||
5 | #include <the_Foundation/string.h> | ||
6 | |||
7 | iDeclareType(Window) | ||
8 | |||
9 | enum iUserEventCode { | ||
10 | command_UserEventCode = 1, | ||
11 | }; | ||
12 | |||
13 | const iString *execPath_App (void); | ||
14 | |||
15 | int run_App (int argc, char **argv); | ||
16 | void processEvents_App (void); | ||
17 | void refresh_App (void); | ||
18 | |||
19 | iAny * findWidget_App (const char *id); | ||
20 | void addTicker_App (void (*ticker)(iAny *), iAny *context); | ||
21 | |||
22 | void postCommand_App (const char *command); | ||
23 | void postCommandf_App (const char *command, ...); | ||
24 | |||
25 | iLocalDef void postCommandString_App(const iString *command) { | ||
26 | postCommand_App(cstr_String(command)); | ||
27 | } | ||
28 | |||
29 | iBool handleCommand_App (const char *cmd); | ||
diff --git a/src/main.c b/src/main.c new file mode 100644 index 00000000..457cc1f2 --- /dev/null +++ b/src/main.c | |||
@@ -0,0 +1,25 @@ | |||
1 | #include <the_Foundation/commandline.h> | ||
2 | #include <stdio.h> | ||
3 | #if defined (iPlatformMsys) | ||
4 | # define SDL_MAIN_HANDLED | ||
5 | #endif | ||
6 | #include <SDL.h> | ||
7 | |||
8 | #include "app.h" | ||
9 | |||
10 | int main(int argc, char **argv) { | ||
11 | #if defined (iPlatformMsys) | ||
12 | /* MSYS runtime takes care of WinMain. */ | ||
13 | SDL_SetMainReady(); | ||
14 | #endif | ||
15 | init_Foundation(); | ||
16 | printf("Lagrange: A Beautiful Gemini Client\n"); | ||
17 | /* Initialize SDL. */ | ||
18 | if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO)) { | ||
19 | fprintf(stderr, "SDL init failed: %s\n", SDL_GetError()); | ||
20 | return -1; | ||
21 | } | ||
22 | run_App(argc, argv); | ||
23 | SDL_Quit(); | ||
24 | return 0; | ||
25 | } | ||
diff --git a/src/stb_image.h b/src/stb_image.h new file mode 100644 index 00000000..2857f05d --- /dev/null +++ b/src/stb_image.h | |||
@@ -0,0 +1,7656 @@ | |||
1 | /* stb_image - v2.25 - public domain image loader - http://nothings.org/stb | ||
2 | no warranty implied; use at your own risk | ||
3 | |||
4 | Do this: | ||
5 | #define STB_IMAGE_IMPLEMENTATION | ||
6 | before you include this file in *one* C or C++ file to create the implementation. | ||
7 | |||
8 | // i.e. it should look like this: | ||
9 | #include ... | ||
10 | #include ... | ||
11 | #include ... | ||
12 | #define STB_IMAGE_IMPLEMENTATION | ||
13 | #include "stb_image.h" | ||
14 | |||
15 | You can #define STBI_ASSERT(x) before the #include to avoid using assert.h. | ||
16 | And #define STBI_MALLOC, STBI_REALLOC, and STBI_FREE to avoid using malloc,realloc,free | ||
17 | |||
18 | |||
19 | QUICK NOTES: | ||
20 | Primarily of interest to game developers and other people who can | ||
21 | avoid problematic images and only need the trivial interface | ||
22 | |||
23 | JPEG baseline & progressive (12 bpc/arithmetic not supported, same as stock IJG lib) | ||
24 | PNG 1/2/4/8/16-bit-per-channel | ||
25 | |||
26 | TGA (not sure what subset, if a subset) | ||
27 | BMP non-1bpp, non-RLE | ||
28 | PSD (composited view only, no extra channels, 8/16 bit-per-channel) | ||
29 | |||
30 | GIF (*comp always reports as 4-channel) | ||
31 | HDR (radiance rgbE format) | ||
32 | PIC (Softimage PIC) | ||
33 | PNM (PPM and PGM binary only) | ||
34 | |||
35 | Animated GIF still needs a proper API, but here's one way to do it: | ||
36 | http://gist.github.com/urraka/685d9a6340b26b830d49 | ||
37 | |||
38 | - decode from memory or through FILE (define STBI_NO_STDIO to remove code) | ||
39 | - decode from arbitrary I/O callbacks | ||
40 | - SIMD acceleration on x86/x64 (SSE2) and ARM (NEON) | ||
41 | |||
42 | Full documentation under "DOCUMENTATION" below. | ||
43 | |||
44 | |||
45 | LICENSE | ||
46 | |||
47 | See end of file for license information. | ||
48 | |||
49 | RECENT REVISION HISTORY: | ||
50 | |||
51 | 2.25 (2020-02-02) fix warnings | ||
52 | 2.24 (2020-02-02) fix warnings; thread-local failure_reason and flip_vertically | ||
53 | 2.23 (2019-08-11) fix clang static analysis warning | ||
54 | 2.22 (2019-03-04) gif fixes, fix warnings | ||
55 | 2.21 (2019-02-25) fix typo in comment | ||
56 | 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs | ||
57 | 2.19 (2018-02-11) fix warning | ||
58 | 2.18 (2018-01-30) fix warnings | ||
59 | 2.17 (2018-01-29) bugfix, 1-bit BMP, 16-bitness query, fix warnings | ||
60 | 2.16 (2017-07-23) all functions have 16-bit variants; optimizations; bugfixes | ||
61 | 2.15 (2017-03-18) fix png-1,2,4; all Imagenet JPGs; no runtime SSE detection on GCC | ||
62 | 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs | ||
63 | 2.13 (2016-12-04) experimental 16-bit API, only for PNG so far; fixes | ||
64 | 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes | ||
65 | 2.11 (2016-04-02) 16-bit PNGS; enable SSE2 in non-gcc x64 | ||
66 | RGB-format JPEG; remove white matting in PSD; | ||
67 | allocate large structures on the stack; | ||
68 | correct channel count for PNG & BMP | ||
69 | 2.10 (2016-01-22) avoid warning introduced in 2.09 | ||
70 | 2.09 (2016-01-16) 16-bit TGA; comments in PNM files; STBI_REALLOC_SIZED | ||
71 | |||
72 | See end of file for full revision history. | ||
73 | |||
74 | |||
75 | ============================ Contributors ========================= | ||
76 | |||
77 | Image formats Extensions, features | ||
78 | Sean Barrett (jpeg, png, bmp) Jetro Lauha (stbi_info) | ||
79 | Nicolas Schulz (hdr, psd) Martin "SpartanJ" Golini (stbi_info) | ||
80 | Jonathan Dummer (tga) James "moose2000" Brown (iPhone PNG) | ||
81 | Jean-Marc Lienher (gif) Ben "Disch" Wenger (io callbacks) | ||
82 | Tom Seddon (pic) Omar Cornut (1/2/4-bit PNG) | ||
83 | Thatcher Ulrich (psd) Nicolas Guillemot (vertical flip) | ||
84 | Ken Miller (pgm, ppm) Richard Mitton (16-bit PSD) | ||
85 | github:urraka (animated gif) Junggon Kim (PNM comments) | ||
86 | Christopher Forseth (animated gif) Daniel Gibson (16-bit TGA) | ||
87 | socks-the-fox (16-bit PNG) | ||
88 | Jeremy Sawicki (handle all ImageNet JPGs) | ||
89 | Optimizations & bugfixes Mikhail Morozov (1-bit BMP) | ||
90 | Fabian "ryg" Giesen Anael Seghezzi (is-16-bit query) | ||
91 | Arseny Kapoulkine | ||
92 | John-Mark Allen | ||
93 | Carmelo J Fdez-Aguera | ||
94 | |||
95 | Bug & warning fixes | ||
96 | Marc LeBlanc David Woo Guillaume George Martins Mozeiko | ||
97 | Christpher Lloyd Jerry Jansson Joseph Thomson Phil Jordan | ||
98 | Dave Moore Roy Eltham Hayaki Saito Nathan Reed | ||
99 | Won Chun Luke Graham Johan Duparc Nick Verigakis | ||
100 | the Horde3D community Thomas Ruf Ronny Chevalier github:rlyeh | ||
101 | Janez Zemva John Bartholomew Michal Cichon github:romigrou | ||
102 | Jonathan Blow Ken Hamada Tero Hanninen github:svdijk | ||
103 | Laurent Gomila Cort Stratton Sergio Gonzalez github:snagar | ||
104 | Aruelien Pocheville Thibault Reuille Cass Everitt github:Zelex | ||
105 | Ryamond Barbiero Paul Du Bois Engin Manap github:grim210 | ||
106 | Aldo Culquicondor Philipp Wiesemann Dale Weiler github:sammyhw | ||
107 | Oriol Ferrer Mesia Josh Tobin Matthew Gregan github:phprus | ||
108 | Julian Raschke Gregory Mullen Baldur Karlsson github:poppolopoppo | ||
109 | Christian Floisand Kevin Schmidt JR Smith github:darealshinji | ||
110 | Brad Weinberger Matvey Cherevko github:Michaelangel007 | ||
111 | Blazej Dariusz Roszkowski Alexander Veselov | ||
112 | */ | ||
113 | |||
114 | #ifndef STBI_INCLUDE_STB_IMAGE_H | ||
115 | #define STBI_INCLUDE_STB_IMAGE_H | ||
116 | |||
117 | // DOCUMENTATION | ||
118 | // | ||
119 | // Limitations: | ||
120 | // - no 12-bit-per-channel JPEG | ||
121 | // - no JPEGs with arithmetic coding | ||
122 | // - GIF always returns *comp=4 | ||
123 | // | ||
124 | // Basic usage (see HDR discussion below for HDR usage): | ||
125 | // int x,y,n; | ||
126 | // unsigned char *data = stbi_load(filename, &x, &y, &n, 0); | ||
127 | // // ... process data if not NULL ... | ||
128 | // // ... x = width, y = height, n = # 8-bit components per pixel ... | ||
129 | // // ... replace '0' with '1'..'4' to force that many components per pixel | ||
130 | // // ... but 'n' will always be the number that it would have been if you said 0 | ||
131 | // stbi_image_free(data) | ||
132 | // | ||
133 | // Standard parameters: | ||
134 | // int *x -- outputs image width in pixels | ||
135 | // int *y -- outputs image height in pixels | ||
136 | // int *channels_in_file -- outputs # of image components in image file | ||
137 | // int desired_channels -- if non-zero, # of image components requested in result | ||
138 | // | ||
139 | // The return value from an image loader is an 'unsigned char *' which points | ||
140 | // to the pixel data, or NULL on an allocation failure or if the image is | ||
141 | // corrupt or invalid. The pixel data consists of *y scanlines of *x pixels, | ||
142 | // with each pixel consisting of N interleaved 8-bit components; the first | ||
143 | // pixel pointed to is top-left-most in the image. There is no padding between | ||
144 | // image scanlines or between pixels, regardless of format. The number of | ||
145 | // components N is 'desired_channels' if desired_channels is non-zero, or | ||
146 | // *channels_in_file otherwise. If desired_channels is non-zero, | ||
147 | // *channels_in_file has the number of components that _would_ have been | ||
148 | // output otherwise. E.g. if you set desired_channels to 4, you will always | ||
149 | // get RGBA output, but you can check *channels_in_file to see if it's trivially | ||
150 | // opaque because e.g. there were only 3 channels in the source image. | ||
151 | // | ||
152 | // An output image with N components has the following components interleaved | ||
153 | // in this order in each pixel: | ||
154 | // | ||
155 | // N=#comp components | ||
156 | // 1 grey | ||
157 | // 2 grey, alpha | ||
158 | // 3 red, green, blue | ||
159 | // 4 red, green, blue, alpha | ||
160 | // | ||
161 | // If image loading fails for any reason, the return value will be NULL, | ||
162 | // and *x, *y, *channels_in_file will be unchanged. The function | ||
163 | // stbi_failure_reason() can be queried for an extremely brief, end-user | ||
164 | // unfriendly explanation of why the load failed. Define STBI_NO_FAILURE_STRINGS | ||
165 | // to avoid compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly | ||
166 | // more user-friendly ones. | ||
167 | // | ||
168 | // Paletted PNG, BMP, GIF, and PIC images are automatically depalettized. | ||
169 | // | ||
170 | // =========================================================================== | ||
171 | // | ||
172 | // UNICODE: | ||
173 | // | ||
174 | // If compiling for Windows and you wish to use Unicode filenames, compile | ||
175 | // with | ||
176 | // #define STBI_WINDOWS_UTF8 | ||
177 | // and pass utf8-encoded filenames. Call stbi_convert_wchar_to_utf8 to convert | ||
178 | // Windows wchar_t filenames to utf8. | ||
179 | // | ||
180 | // =========================================================================== | ||
181 | // | ||
182 | // Philosophy | ||
183 | // | ||
184 | // stb libraries are designed with the following priorities: | ||
185 | // | ||
186 | // 1. easy to use | ||
187 | // 2. easy to maintain | ||
188 | // 3. good performance | ||
189 | // | ||
190 | // Sometimes I let "good performance" creep up in priority over "easy to maintain", | ||
191 | // and for best performance I may provide less-easy-to-use APIs that give higher | ||
192 | // performance, in addition to the easy-to-use ones. Nevertheless, it's important | ||
193 | // to keep in mind that from the standpoint of you, a client of this library, | ||
194 | // all you care about is #1 and #3, and stb libraries DO NOT emphasize #3 above all. | ||
195 | // | ||
196 | // Some secondary priorities arise directly from the first two, some of which | ||
197 | // provide more explicit reasons why performance can't be emphasized. | ||
198 | // | ||
199 | // - Portable ("ease of use") | ||
200 | // - Small source code footprint ("easy to maintain") | ||
201 | // - No dependencies ("ease of use") | ||
202 | // | ||
203 | // =========================================================================== | ||
204 | // | ||
205 | // I/O callbacks | ||
206 | // | ||
207 | // I/O callbacks allow you to read from arbitrary sources, like packaged | ||
208 | // files or some other source. Data read from callbacks are processed | ||
209 | // through a small internal buffer (currently 128 bytes) to try to reduce | ||
210 | // overhead. | ||
211 | // | ||
212 | // The three functions you must define are "read" (reads some bytes of data), | ||
213 | // "skip" (skips some bytes of data), "eof" (reports if the stream is at the end). | ||
214 | // | ||
215 | // =========================================================================== | ||
216 | // | ||
217 | // SIMD support | ||
218 | // | ||
219 | // The JPEG decoder will try to automatically use SIMD kernels on x86 when | ||
220 | // supported by the compiler. For ARM Neon support, you must explicitly | ||
221 | // request it. | ||
222 | // | ||
223 | // (The old do-it-yourself SIMD API is no longer supported in the current | ||
224 | // code.) | ||
225 | // | ||
226 | // On x86, SSE2 will automatically be used when available based on a run-time | ||
227 | // test; if not, the generic C versions are used as a fall-back. On ARM targets, | ||
228 | // the typical path is to have separate builds for NEON and non-NEON devices | ||
229 | // (at least this is true for iOS and Android). Therefore, the NEON support is | ||
230 | // toggled by a build flag: define STBI_NEON to get NEON loops. | ||
231 | // | ||
232 | // If for some reason you do not want to use any of SIMD code, or if | ||
233 | // you have issues compiling it, you can disable it entirely by | ||
234 | // defining STBI_NO_SIMD. | ||
235 | // | ||
236 | // =========================================================================== | ||
237 | // | ||
238 | // HDR image support (disable by defining STBI_NO_HDR) | ||
239 | // | ||
240 | // stb_image supports loading HDR images in general, and currently the Radiance | ||
241 | // .HDR file format specifically. You can still load any file through the existing | ||
242 | // interface; if you attempt to load an HDR file, it will be automatically remapped | ||
243 | // to LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1; | ||
244 | // both of these constants can be reconfigured through this interface: | ||
245 | // | ||
246 | // stbi_hdr_to_ldr_gamma(2.2f); | ||
247 | // stbi_hdr_to_ldr_scale(1.0f); | ||
248 | // | ||
249 | // (note, do not use _inverse_ constants; stbi_image will invert them | ||
250 | // appropriately). | ||
251 | // | ||
252 | // Additionally, there is a new, parallel interface for loading files as | ||
253 | // (linear) floats to preserve the full dynamic range: | ||
254 | // | ||
255 | // float *data = stbi_loadf(filename, &x, &y, &n, 0); | ||
256 | // | ||
257 | // If you load LDR images through this interface, those images will | ||
258 | // be promoted to floating point values, run through the inverse of | ||
259 | // constants corresponding to the above: | ||
260 | // | ||
261 | // stbi_ldr_to_hdr_scale(1.0f); | ||
262 | // stbi_ldr_to_hdr_gamma(2.2f); | ||
263 | // | ||
264 | // Finally, given a filename (or an open file or memory block--see header | ||
265 | // file for details) containing image data, you can query for the "most | ||
266 | // appropriate" interface to use (that is, whether the image is HDR or | ||
267 | // not), using: | ||
268 | // | ||
269 | // stbi_is_hdr(char *filename); | ||
270 | // | ||
271 | // =========================================================================== | ||
272 | // | ||
273 | // iPhone PNG support: | ||
274 | // | ||
275 | // By default we convert iphone-formatted PNGs back to RGB, even though | ||
276 | // they are internally encoded differently. You can disable this conversion | ||
277 | // by calling stbi_convert_iphone_png_to_rgb(0), in which case | ||
278 | // you will always just get the native iphone "format" through (which | ||
279 | // is BGR stored in RGB). | ||
280 | // | ||
281 | // Call stbi_set_unpremultiply_on_load(1) as well to force a divide per | ||
282 | // pixel to remove any premultiplied alpha *only* if the image file explicitly | ||
283 | // says there's premultiplied data (currently only happens in iPhone images, | ||
284 | // and only if iPhone convert-to-rgb processing is on). | ||
285 | // | ||
286 | // =========================================================================== | ||
287 | // | ||
288 | // ADDITIONAL CONFIGURATION | ||
289 | // | ||
290 | // - You can suppress implementation of any of the decoders to reduce | ||
291 | // your code footprint by #defining one or more of the following | ||
292 | // symbols before creating the implementation. | ||
293 | // | ||
294 | // STBI_NO_JPEG | ||
295 | // STBI_NO_PNG | ||
296 | // STBI_NO_BMP | ||
297 | // STBI_NO_PSD | ||
298 | // STBI_NO_TGA | ||
299 | // STBI_NO_GIF | ||
300 | // STBI_NO_HDR | ||
301 | // STBI_NO_PIC | ||
302 | // STBI_NO_PNM (.ppm and .pgm) | ||
303 | // | ||
304 | // - You can request *only* certain decoders and suppress all other ones | ||
305 | // (this will be more forward-compatible, as addition of new decoders | ||
306 | // doesn't require you to disable them explicitly): | ||
307 | // | ||
308 | // STBI_ONLY_JPEG | ||
309 | // STBI_ONLY_PNG | ||
310 | // STBI_ONLY_BMP | ||
311 | // STBI_ONLY_PSD | ||
312 | // STBI_ONLY_TGA | ||
313 | // STBI_ONLY_GIF | ||
314 | // STBI_ONLY_HDR | ||
315 | // STBI_ONLY_PIC | ||
316 | // STBI_ONLY_PNM (.ppm and .pgm) | ||
317 | // | ||
318 | // - If you use STBI_NO_PNG (or _ONLY_ without PNG), and you still | ||
319 | // want the zlib decoder to be available, #define STBI_SUPPORT_ZLIB | ||
320 | // | ||
321 | |||
322 | |||
323 | #ifndef STBI_NO_STDIO | ||
324 | #include <stdio.h> | ||
325 | #endif // STBI_NO_STDIO | ||
326 | |||
327 | #define STBI_VERSION 1 | ||
328 | |||
329 | enum | ||
330 | { | ||
331 | STBI_default = 0, // only used for desired_channels | ||
332 | |||
333 | STBI_grey = 1, | ||
334 | STBI_grey_alpha = 2, | ||
335 | STBI_rgb = 3, | ||
336 | STBI_rgb_alpha = 4 | ||
337 | }; | ||
338 | |||
339 | #include <stdlib.h> | ||
340 | typedef unsigned char stbi_uc; | ||
341 | typedef unsigned short stbi_us; | ||
342 | |||
343 | #ifdef __cplusplus | ||
344 | extern "C" { | ||
345 | #endif | ||
346 | |||
347 | #ifndef STBIDEF | ||
348 | #ifdef STB_IMAGE_STATIC | ||
349 | #define STBIDEF static | ||
350 | #else | ||
351 | #define STBIDEF extern | ||
352 | #endif | ||
353 | #endif | ||
354 | |||
355 | ////////////////////////////////////////////////////////////////////////////// | ||
356 | // | ||
357 | // PRIMARY API - works on images of any type | ||
358 | // | ||
359 | |||
360 | // | ||
361 | // load image by filename, open file, or memory buffer | ||
362 | // | ||
363 | |||
364 | typedef struct | ||
365 | { | ||
366 | int (*read) (void *user,char *data,int size); // fill 'data' with 'size' bytes. return number of bytes actually read | ||
367 | void (*skip) (void *user,int n); // skip the next 'n' bytes, or 'unget' the last -n bytes if negative | ||
368 | int (*eof) (void *user); // returns nonzero if we are at end of file/data | ||
369 | } stbi_io_callbacks; | ||
370 | |||
371 | //////////////////////////////////// | ||
372 | // | ||
373 | // 8-bits-per-channel interface | ||
374 | // | ||
375 | |||
376 | STBIDEF stbi_uc *stbi_load_from_memory (stbi_uc const *buffer, int len , int *x, int *y, int *channels_in_file, int desired_channels); | ||
377 | STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk , void *user, int *x, int *y, int *channels_in_file, int desired_channels); | ||
378 | |||
379 | #ifndef STBI_NO_STDIO | ||
380 | STBIDEF stbi_uc *stbi_load (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); | ||
381 | STBIDEF stbi_uc *stbi_load_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); | ||
382 | // for stbi_load_from_file, file pointer is left pointing immediately after image | ||
383 | #endif | ||
384 | |||
385 | #ifndef STBI_NO_GIF | ||
386 | STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp); | ||
387 | #endif | ||
388 | |||
389 | #ifdef STBI_WINDOWS_UTF8 | ||
390 | STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input); | ||
391 | #endif | ||
392 | |||
393 | //////////////////////////////////// | ||
394 | // | ||
395 | // 16-bits-per-channel interface | ||
396 | // | ||
397 | |||
398 | STBIDEF stbi_us *stbi_load_16_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels); | ||
399 | STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels); | ||
400 | |||
401 | #ifndef STBI_NO_STDIO | ||
402 | STBIDEF stbi_us *stbi_load_16 (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); | ||
403 | STBIDEF stbi_us *stbi_load_from_file_16(FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); | ||
404 | #endif | ||
405 | |||
406 | //////////////////////////////////// | ||
407 | // | ||
408 | // float-per-channel interface | ||
409 | // | ||
410 | #ifndef STBI_NO_LINEAR | ||
411 | STBIDEF float *stbi_loadf_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels); | ||
412 | STBIDEF float *stbi_loadf_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels); | ||
413 | |||
414 | #ifndef STBI_NO_STDIO | ||
415 | STBIDEF float *stbi_loadf (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); | ||
416 | STBIDEF float *stbi_loadf_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); | ||
417 | #endif | ||
418 | #endif | ||
419 | |||
420 | #ifndef STBI_NO_HDR | ||
421 | STBIDEF void stbi_hdr_to_ldr_gamma(float gamma); | ||
422 | STBIDEF void stbi_hdr_to_ldr_scale(float scale); | ||
423 | #endif // STBI_NO_HDR | ||
424 | |||
425 | #ifndef STBI_NO_LINEAR | ||
426 | STBIDEF void stbi_ldr_to_hdr_gamma(float gamma); | ||
427 | STBIDEF void stbi_ldr_to_hdr_scale(float scale); | ||
428 | #endif // STBI_NO_LINEAR | ||
429 | |||
430 | // stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR | ||
431 | STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user); | ||
432 | STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len); | ||
433 | #ifndef STBI_NO_STDIO | ||
434 | STBIDEF int stbi_is_hdr (char const *filename); | ||
435 | STBIDEF int stbi_is_hdr_from_file(FILE *f); | ||
436 | #endif // STBI_NO_STDIO | ||
437 | |||
438 | |||
439 | // get a VERY brief reason for failure | ||
440 | // on most compilers (and ALL modern mainstream compilers) this is threadsafe | ||
441 | STBIDEF const char *stbi_failure_reason (void); | ||
442 | |||
443 | // free the loaded image -- this is just free() | ||
444 | STBIDEF void stbi_image_free (void *retval_from_stbi_load); | ||
445 | |||
446 | // get image dimensions & components without fully decoding | ||
447 | STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp); | ||
448 | STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp); | ||
449 | STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len); | ||
450 | STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *clbk, void *user); | ||
451 | |||
452 | #ifndef STBI_NO_STDIO | ||
453 | STBIDEF int stbi_info (char const *filename, int *x, int *y, int *comp); | ||
454 | STBIDEF int stbi_info_from_file (FILE *f, int *x, int *y, int *comp); | ||
455 | STBIDEF int stbi_is_16_bit (char const *filename); | ||
456 | STBIDEF int stbi_is_16_bit_from_file(FILE *f); | ||
457 | #endif | ||
458 | |||
459 | |||
460 | |||
461 | // for image formats that explicitly notate that they have premultiplied alpha, | ||
462 | // we just return the colors as stored in the file. set this flag to force | ||
463 | // unpremultiplication. results are undefined if the unpremultiply overflow. | ||
464 | STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply); | ||
465 | |||
466 | // indicate whether we should process iphone images back to canonical format, | ||
467 | // or just pass them through "as-is" | ||
468 | STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert); | ||
469 | |||
470 | // flip the image vertically, so the first pixel in the output array is the bottom left | ||
471 | STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip); | ||
472 | |||
473 | // as above, but only applies to images loaded on the thread that calls the function | ||
474 | // this function is only available if your compiler supports thread-local variables; | ||
475 | // calling it will fail to link if your compiler doesn't | ||
476 | STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip); | ||
477 | |||
478 | // ZLIB client - used by PNG, available for other purposes | ||
479 | |||
480 | STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen); | ||
481 | STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header); | ||
482 | STBIDEF char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen); | ||
483 | STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); | ||
484 | |||
485 | STBIDEF char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen); | ||
486 | STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); | ||
487 | |||
488 | |||
489 | #ifdef __cplusplus | ||
490 | } | ||
491 | #endif | ||
492 | |||
493 | // | ||
494 | // | ||
495 | //// end header file ///////////////////////////////////////////////////// | ||
496 | #endif // STBI_INCLUDE_STB_IMAGE_H | ||
497 | |||
498 | #ifdef STB_IMAGE_IMPLEMENTATION | ||
499 | |||
500 | #if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) \ | ||
501 | || defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \ | ||
502 | || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) \ | ||
503 | || defined(STBI_ONLY_ZLIB) | ||
504 | #ifndef STBI_ONLY_JPEG | ||
505 | #define STBI_NO_JPEG | ||
506 | #endif | ||
507 | #ifndef STBI_ONLY_PNG | ||
508 | #define STBI_NO_PNG | ||
509 | #endif | ||
510 | #ifndef STBI_ONLY_BMP | ||
511 | #define STBI_NO_BMP | ||
512 | #endif | ||
513 | #ifndef STBI_ONLY_PSD | ||
514 | #define STBI_NO_PSD | ||
515 | #endif | ||
516 | #ifndef STBI_ONLY_TGA | ||
517 | #define STBI_NO_TGA | ||
518 | #endif | ||
519 | #ifndef STBI_ONLY_GIF | ||
520 | #define STBI_NO_GIF | ||
521 | #endif | ||
522 | #ifndef STBI_ONLY_HDR | ||
523 | #define STBI_NO_HDR | ||
524 | #endif | ||
525 | #ifndef STBI_ONLY_PIC | ||
526 | #define STBI_NO_PIC | ||
527 | #endif | ||
528 | #ifndef STBI_ONLY_PNM | ||
529 | #define STBI_NO_PNM | ||
530 | #endif | ||
531 | #endif | ||
532 | |||
533 | #if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB) | ||
534 | #define STBI_NO_ZLIB | ||
535 | #endif | ||
536 | |||
537 | |||
538 | #include <stdarg.h> | ||
539 | #include <stddef.h> // ptrdiff_t on osx | ||
540 | #include <stdlib.h> | ||
541 | #include <string.h> | ||
542 | #include <limits.h> | ||
543 | |||
544 | #if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) | ||
545 | #include <math.h> // ldexp, pow | ||
546 | #endif | ||
547 | |||
548 | #ifndef STBI_NO_STDIO | ||
549 | #include <stdio.h> | ||
550 | #endif | ||
551 | |||
552 | #ifndef STBI_ASSERT | ||
553 | #include <assert.h> | ||
554 | #define STBI_ASSERT(x) assert(x) | ||
555 | #endif | ||
556 | |||
557 | #ifdef __cplusplus | ||
558 | #define STBI_EXTERN extern "C" | ||
559 | #else | ||
560 | #define STBI_EXTERN extern | ||
561 | #endif | ||
562 | |||
563 | |||
564 | #ifndef _MSC_VER | ||
565 | #ifdef __cplusplus | ||
566 | #define stbi_inline inline | ||
567 | #else | ||
568 | #define stbi_inline | ||
569 | #endif | ||
570 | #else | ||
571 | #define stbi_inline __forceinline | ||
572 | #endif | ||
573 | |||
574 | #ifndef STBI_NO_THREAD_LOCALS | ||
575 | #if defined(__cplusplus) && __cplusplus >= 201103L | ||
576 | #define STBI_THREAD_LOCAL thread_local | ||
577 | #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L | ||
578 | #define STBI_THREAD_LOCAL _Thread_local | ||
579 | #elif defined(__GNUC__) | ||
580 | #define STBI_THREAD_LOCAL __thread | ||
581 | #elif defined(_MSC_VER) | ||
582 | #define STBI_THREAD_LOCAL __declspec(thread) | ||
583 | #endif | ||
584 | #endif | ||
585 | |||
586 | #ifdef _MSC_VER | ||
587 | typedef unsigned short stbi__uint16; | ||
588 | typedef signed short stbi__int16; | ||
589 | typedef unsigned int stbi__uint32; | ||
590 | typedef signed int stbi__int32; | ||
591 | #else | ||
592 | #include <stdint.h> | ||
593 | typedef uint16_t stbi__uint16; | ||
594 | typedef int16_t stbi__int16; | ||
595 | typedef uint32_t stbi__uint32; | ||
596 | typedef int32_t stbi__int32; | ||
597 | #endif | ||
598 | |||
599 | // should produce compiler error if size is wrong | ||
600 | typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1]; | ||
601 | |||
602 | #ifdef _MSC_VER | ||
603 | #define STBI_NOTUSED(v) (void)(v) | ||
604 | #else | ||
605 | #define STBI_NOTUSED(v) (void)sizeof(v) | ||
606 | #endif | ||
607 | |||
608 | #ifdef _MSC_VER | ||
609 | #define STBI_HAS_LROTL | ||
610 | #endif | ||
611 | |||
612 | #ifdef STBI_HAS_LROTL | ||
613 | #define stbi_lrot(x,y) _lrotl(x,y) | ||
614 | #else | ||
615 | #define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (32 - (y)))) | ||
616 | #endif | ||
617 | |||
618 | #if defined(STBI_MALLOC) && defined(STBI_FREE) && (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED)) | ||
619 | // ok | ||
620 | #elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) && !defined(STBI_REALLOC_SIZED) | ||
621 | // ok | ||
622 | #else | ||
623 | #error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC (or STBI_REALLOC_SIZED)." | ||
624 | #endif | ||
625 | |||
626 | #ifndef STBI_MALLOC | ||
627 | #define STBI_MALLOC(sz) malloc(sz) | ||
628 | #define STBI_REALLOC(p,newsz) realloc(p,newsz) | ||
629 | #define STBI_FREE(p) free(p) | ||
630 | #endif | ||
631 | |||
632 | #ifndef STBI_REALLOC_SIZED | ||
633 | #define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz) | ||
634 | #endif | ||
635 | |||
636 | // x86/x64 detection | ||
637 | #if defined(__x86_64__) || defined(_M_X64) | ||
638 | #define STBI__X64_TARGET | ||
639 | #elif defined(__i386) || defined(_M_IX86) | ||
640 | #define STBI__X86_TARGET | ||
641 | #endif | ||
642 | |||
643 | #if defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD) | ||
644 | // gcc doesn't support sse2 intrinsics unless you compile with -msse2, | ||
645 | // which in turn means it gets to use SSE2 everywhere. This is unfortunate, | ||
646 | // but previous attempts to provide the SSE2 functions with runtime | ||
647 | // detection caused numerous issues. The way architecture extensions are | ||
648 | // exposed in GCC/Clang is, sadly, not really suited for one-file libs. | ||
649 | // New behavior: if compiled with -msse2, we use SSE2 without any | ||
650 | // detection; if not, we don't use it at all. | ||
651 | #define STBI_NO_SIMD | ||
652 | #endif | ||
653 | |||
654 | #if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD) | ||
655 | // Note that __MINGW32__ doesn't actually mean 32-bit, so we have to avoid STBI__X64_TARGET | ||
656 | // | ||
657 | // 32-bit MinGW wants ESP to be 16-byte aligned, but this is not in the | ||
658 | // Windows ABI and VC++ as well as Windows DLLs don't maintain that invariant. | ||
659 | // As a result, enabling SSE2 on 32-bit MinGW is dangerous when not | ||
660 | // simultaneously enabling "-mstackrealign". | ||
661 | // | ||
662 | // See https://github.com/nothings/stb/issues/81 for more information. | ||
663 | // | ||
664 | // So default to no SSE2 on 32-bit MinGW. If you've read this far and added | ||
665 | // -mstackrealign to your build settings, feel free to #define STBI_MINGW_ENABLE_SSE2. | ||
666 | #define STBI_NO_SIMD | ||
667 | #endif | ||
668 | |||
669 | #if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET)) | ||
670 | #define STBI_SSE2 | ||
671 | #include <emmintrin.h> | ||
672 | |||
673 | #ifdef _MSC_VER | ||
674 | |||
675 | #if _MSC_VER >= 1400 // not VC6 | ||
676 | #include <intrin.h> // __cpuid | ||
677 | static int stbi__cpuid3(void) | ||
678 | { | ||
679 | int info[4]; | ||
680 | __cpuid(info,1); | ||
681 | return info[3]; | ||
682 | } | ||
683 | #else | ||
684 | static int stbi__cpuid3(void) | ||
685 | { | ||
686 | int res; | ||
687 | __asm { | ||
688 | mov eax,1 | ||
689 | cpuid | ||
690 | mov res,edx | ||
691 | } | ||
692 | return res; | ||
693 | } | ||
694 | #endif | ||
695 | |||
696 | #define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name | ||
697 | |||
698 | #if !defined(STBI_NO_JPEG) && defined(STBI_SSE2) | ||
699 | static int stbi__sse2_available(void) | ||
700 | { | ||
701 | int info3 = stbi__cpuid3(); | ||
702 | return ((info3 >> 26) & 1) != 0; | ||
703 | } | ||
704 | #endif | ||
705 | |||
706 | #else // assume GCC-style if not VC++ | ||
707 | #define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) | ||
708 | |||
709 | #if !defined(STBI_NO_JPEG) && defined(STBI_SSE2) | ||
710 | static int stbi__sse2_available(void) | ||
711 | { | ||
712 | // If we're even attempting to compile this on GCC/Clang, that means | ||
713 | // -msse2 is on, which means the compiler is allowed to use SSE2 | ||
714 | // instructions at will, and so are we. | ||
715 | return 1; | ||
716 | } | ||
717 | #endif | ||
718 | |||
719 | #endif | ||
720 | #endif | ||
721 | |||
722 | // ARM NEON | ||
723 | #if defined(STBI_NO_SIMD) && defined(STBI_NEON) | ||
724 | #undef STBI_NEON | ||
725 | #endif | ||
726 | |||
727 | #ifdef STBI_NEON | ||
728 | #include <arm_neon.h> | ||
729 | // assume GCC or Clang on ARM targets | ||
730 | #define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) | ||
731 | #endif | ||
732 | |||
733 | #ifndef STBI_SIMD_ALIGN | ||
734 | #define STBI_SIMD_ALIGN(type, name) type name | ||
735 | #endif | ||
736 | |||
737 | /////////////////////////////////////////////// | ||
738 | // | ||
739 | // stbi__context struct and start_xxx functions | ||
740 | |||
741 | // stbi__context structure is our basic context used by all images, so it | ||
742 | // contains all the IO context, plus some basic image information | ||
743 | typedef struct | ||
744 | { | ||
745 | stbi__uint32 img_x, img_y; | ||
746 | int img_n, img_out_n; | ||
747 | |||
748 | stbi_io_callbacks io; | ||
749 | void *io_user_data; | ||
750 | |||
751 | int read_from_callbacks; | ||
752 | int buflen; | ||
753 | stbi_uc buffer_start[128]; | ||
754 | |||
755 | stbi_uc *img_buffer, *img_buffer_end; | ||
756 | stbi_uc *img_buffer_original, *img_buffer_original_end; | ||
757 | } stbi__context; | ||
758 | |||
759 | |||
760 | static void stbi__refill_buffer(stbi__context *s); | ||
761 | |||
762 | // initialize a memory-decode context | ||
763 | static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len) | ||
764 | { | ||
765 | s->io.read = NULL; | ||
766 | s->read_from_callbacks = 0; | ||
767 | s->img_buffer = s->img_buffer_original = (stbi_uc *) buffer; | ||
768 | s->img_buffer_end = s->img_buffer_original_end = (stbi_uc *) buffer+len; | ||
769 | } | ||
770 | |||
771 | // initialize a callback-based context | ||
772 | static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user) | ||
773 | { | ||
774 | s->io = *c; | ||
775 | s->io_user_data = user; | ||
776 | s->buflen = sizeof(s->buffer_start); | ||
777 | s->read_from_callbacks = 1; | ||
778 | s->img_buffer_original = s->buffer_start; | ||
779 | stbi__refill_buffer(s); | ||
780 | s->img_buffer_original_end = s->img_buffer_end; | ||
781 | } | ||
782 | |||
783 | #ifndef STBI_NO_STDIO | ||
784 | |||
785 | static int stbi__stdio_read(void *user, char *data, int size) | ||
786 | { | ||
787 | return (int) fread(data,1,size,(FILE*) user); | ||
788 | } | ||
789 | |||
790 | static void stbi__stdio_skip(void *user, int n) | ||
791 | { | ||
792 | fseek((FILE*) user, n, SEEK_CUR); | ||
793 | } | ||
794 | |||
795 | static int stbi__stdio_eof(void *user) | ||
796 | { | ||
797 | return feof((FILE*) user); | ||
798 | } | ||
799 | |||
800 | static stbi_io_callbacks stbi__stdio_callbacks = | ||
801 | { | ||
802 | stbi__stdio_read, | ||
803 | stbi__stdio_skip, | ||
804 | stbi__stdio_eof, | ||
805 | }; | ||
806 | |||
807 | static void stbi__start_file(stbi__context *s, FILE *f) | ||
808 | { | ||
809 | stbi__start_callbacks(s, &stbi__stdio_callbacks, (void *) f); | ||
810 | } | ||
811 | |||
812 | //static void stop_file(stbi__context *s) { } | ||
813 | |||
814 | #endif // !STBI_NO_STDIO | ||
815 | |||
816 | static void stbi__rewind(stbi__context *s) | ||
817 | { | ||
818 | // conceptually rewind SHOULD rewind to the beginning of the stream, | ||
819 | // but we just rewind to the beginning of the initial buffer, because | ||
820 | // we only use it after doing 'test', which only ever looks at at most 92 bytes | ||
821 | s->img_buffer = s->img_buffer_original; | ||
822 | s->img_buffer_end = s->img_buffer_original_end; | ||
823 | } | ||
824 | |||
825 | enum | ||
826 | { | ||
827 | STBI_ORDER_RGB, | ||
828 | STBI_ORDER_BGR | ||
829 | }; | ||
830 | |||
831 | typedef struct | ||
832 | { | ||
833 | int bits_per_channel; | ||
834 | int num_channels; | ||
835 | int channel_order; | ||
836 | } stbi__result_info; | ||
837 | |||
838 | #ifndef STBI_NO_JPEG | ||
839 | static int stbi__jpeg_test(stbi__context *s); | ||
840 | static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); | ||
841 | static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp); | ||
842 | #endif | ||
843 | |||
844 | #ifndef STBI_NO_PNG | ||
845 | static int stbi__png_test(stbi__context *s); | ||
846 | static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); | ||
847 | static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp); | ||
848 | static int stbi__png_is16(stbi__context *s); | ||
849 | #endif | ||
850 | |||
851 | #ifndef STBI_NO_BMP | ||
852 | static int stbi__bmp_test(stbi__context *s); | ||
853 | static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); | ||
854 | static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp); | ||
855 | #endif | ||
856 | |||
857 | #ifndef STBI_NO_TGA | ||
858 | static int stbi__tga_test(stbi__context *s); | ||
859 | static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); | ||
860 | static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp); | ||
861 | #endif | ||
862 | |||
863 | #ifndef STBI_NO_PSD | ||
864 | static int stbi__psd_test(stbi__context *s); | ||
865 | static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc); | ||
866 | static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp); | ||
867 | static int stbi__psd_is16(stbi__context *s); | ||
868 | #endif | ||
869 | |||
870 | #ifndef STBI_NO_HDR | ||
871 | static int stbi__hdr_test(stbi__context *s); | ||
872 | static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); | ||
873 | static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp); | ||
874 | #endif | ||
875 | |||
876 | #ifndef STBI_NO_PIC | ||
877 | static int stbi__pic_test(stbi__context *s); | ||
878 | static void *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); | ||
879 | static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp); | ||
880 | #endif | ||
881 | |||
882 | #ifndef STBI_NO_GIF | ||
883 | static int stbi__gif_test(stbi__context *s); | ||
884 | static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); | ||
885 | static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp); | ||
886 | static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp); | ||
887 | #endif | ||
888 | |||
889 | #ifndef STBI_NO_PNM | ||
890 | static int stbi__pnm_test(stbi__context *s); | ||
891 | static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); | ||
892 | static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp); | ||
893 | #endif | ||
894 | |||
895 | static | ||
896 | #ifdef STBI_THREAD_LOCAL | ||
897 | STBI_THREAD_LOCAL | ||
898 | #endif | ||
899 | const char *stbi__g_failure_reason; | ||
900 | |||
901 | STBIDEF const char *stbi_failure_reason(void) | ||
902 | { | ||
903 | return stbi__g_failure_reason; | ||
904 | } | ||
905 | |||
906 | #ifndef STBI_NO_FAILURE_STRINGS | ||
907 | static int stbi__err(const char *str) | ||
908 | { | ||
909 | stbi__g_failure_reason = str; | ||
910 | return 0; | ||
911 | } | ||
912 | #endif | ||
913 | |||
914 | static void *stbi__malloc(size_t size) | ||
915 | { | ||
916 | return STBI_MALLOC(size); | ||
917 | } | ||
918 | |||
919 | // stb_image uses ints pervasively, including for offset calculations. | ||
920 | // therefore the largest decoded image size we can support with the | ||
921 | // current code, even on 64-bit targets, is INT_MAX. this is not a | ||
922 | // significant limitation for the intended use case. | ||
923 | // | ||
924 | // we do, however, need to make sure our size calculations don't | ||
925 | // overflow. hence a few helper functions for size calculations that | ||
926 | // multiply integers together, making sure that they're non-negative | ||
927 | // and no overflow occurs. | ||
928 | |||
929 | // return 1 if the sum is valid, 0 on overflow. | ||
930 | // negative terms are considered invalid. | ||
931 | static int stbi__addsizes_valid(int a, int b) | ||
932 | { | ||
933 | if (b < 0) return 0; | ||
934 | // now 0 <= b <= INT_MAX, hence also | ||
935 | // 0 <= INT_MAX - b <= INTMAX. | ||
936 | // And "a + b <= INT_MAX" (which might overflow) is the | ||
937 | // same as a <= INT_MAX - b (no overflow) | ||
938 | return a <= INT_MAX - b; | ||
939 | } | ||
940 | |||
941 | // returns 1 if the product is valid, 0 on overflow. | ||
942 | // negative factors are considered invalid. | ||
943 | static int stbi__mul2sizes_valid(int a, int b) | ||
944 | { | ||
945 | if (a < 0 || b < 0) return 0; | ||
946 | if (b == 0) return 1; // mul-by-0 is always safe | ||
947 | // portable way to check for no overflows in a*b | ||
948 | return a <= INT_MAX/b; | ||
949 | } | ||
950 | |||
951 | #if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR) | ||
952 | // returns 1 if "a*b + add" has no negative terms/factors and doesn't overflow | ||
953 | static int stbi__mad2sizes_valid(int a, int b, int add) | ||
954 | { | ||
955 | return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a*b, add); | ||
956 | } | ||
957 | #endif | ||
958 | |||
959 | // returns 1 if "a*b*c + add" has no negative terms/factors and doesn't overflow | ||
960 | static int stbi__mad3sizes_valid(int a, int b, int c, int add) | ||
961 | { | ||
962 | return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) && | ||
963 | stbi__addsizes_valid(a*b*c, add); | ||
964 | } | ||
965 | |||
966 | // returns 1 if "a*b*c*d + add" has no negative terms/factors and doesn't overflow | ||
967 | #if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) | ||
968 | static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add) | ||
969 | { | ||
970 | return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) && | ||
971 | stbi__mul2sizes_valid(a*b*c, d) && stbi__addsizes_valid(a*b*c*d, add); | ||
972 | } | ||
973 | #endif | ||
974 | |||
975 | #if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR) | ||
976 | // mallocs with size overflow checking | ||
977 | static void *stbi__malloc_mad2(int a, int b, int add) | ||
978 | { | ||
979 | if (!stbi__mad2sizes_valid(a, b, add)) return NULL; | ||
980 | return stbi__malloc(a*b + add); | ||
981 | } | ||
982 | #endif | ||
983 | |||
984 | static void *stbi__malloc_mad3(int a, int b, int c, int add) | ||
985 | { | ||
986 | if (!stbi__mad3sizes_valid(a, b, c, add)) return NULL; | ||
987 | return stbi__malloc(a*b*c + add); | ||
988 | } | ||
989 | |||
990 | #if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) | ||
991 | static void *stbi__malloc_mad4(int a, int b, int c, int d, int add) | ||
992 | { | ||
993 | if (!stbi__mad4sizes_valid(a, b, c, d, add)) return NULL; | ||
994 | return stbi__malloc(a*b*c*d + add); | ||
995 | } | ||
996 | #endif | ||
997 | |||
998 | // stbi__err - error | ||
999 | // stbi__errpf - error returning pointer to float | ||
1000 | // stbi__errpuc - error returning pointer to unsigned char | ||
1001 | |||
1002 | #ifdef STBI_NO_FAILURE_STRINGS | ||
1003 | #define stbi__err(x,y) 0 | ||
1004 | #elif defined(STBI_FAILURE_USERMSG) | ||
1005 | #define stbi__err(x,y) stbi__err(y) | ||
1006 | #else | ||
1007 | #define stbi__err(x,y) stbi__err(x) | ||
1008 | #endif | ||
1009 | |||
1010 | #define stbi__errpf(x,y) ((float *)(size_t) (stbi__err(x,y)?NULL:NULL)) | ||
1011 | #define stbi__errpuc(x,y) ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL)) | ||
1012 | |||
1013 | STBIDEF void stbi_image_free(void *retval_from_stbi_load) | ||
1014 | { | ||
1015 | STBI_FREE(retval_from_stbi_load); | ||
1016 | } | ||
1017 | |||
1018 | #ifndef STBI_NO_LINEAR | ||
1019 | static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp); | ||
1020 | #endif | ||
1021 | |||
1022 | #ifndef STBI_NO_HDR | ||
1023 | static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp); | ||
1024 | #endif | ||
1025 | |||
1026 | static int stbi__vertically_flip_on_load_global = 0; | ||
1027 | |||
1028 | STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip) | ||
1029 | { | ||
1030 | stbi__vertically_flip_on_load_global = flag_true_if_should_flip; | ||
1031 | } | ||
1032 | |||
1033 | #ifndef STBI_THREAD_LOCAL | ||
1034 | #define stbi__vertically_flip_on_load stbi__vertically_flip_on_load_global | ||
1035 | #else | ||
1036 | static STBI_THREAD_LOCAL int stbi__vertically_flip_on_load_local, stbi__vertically_flip_on_load_set; | ||
1037 | |||
1038 | STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip) | ||
1039 | { | ||
1040 | stbi__vertically_flip_on_load_local = flag_true_if_should_flip; | ||
1041 | stbi__vertically_flip_on_load_set = 1; | ||
1042 | } | ||
1043 | |||
1044 | #define stbi__vertically_flip_on_load (stbi__vertically_flip_on_load_set \ | ||
1045 | ? stbi__vertically_flip_on_load_local \ | ||
1046 | : stbi__vertically_flip_on_load_global) | ||
1047 | #endif // STBI_THREAD_LOCAL | ||
1048 | |||
1049 | static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc) | ||
1050 | { | ||
1051 | memset(ri, 0, sizeof(*ri)); // make sure it's initialized if we add new fields | ||
1052 | ri->bits_per_channel = 8; // default is 8 so most paths don't have to be changed | ||
1053 | ri->channel_order = STBI_ORDER_RGB; // all current input & output are this, but this is here so we can add BGR order | ||
1054 | ri->num_channels = 0; | ||
1055 | |||
1056 | #ifndef STBI_NO_JPEG | ||
1057 | if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp, ri); | ||
1058 | #endif | ||
1059 | #ifndef STBI_NO_PNG | ||
1060 | if (stbi__png_test(s)) return stbi__png_load(s,x,y,comp,req_comp, ri); | ||
1061 | #endif | ||
1062 | #ifndef STBI_NO_BMP | ||
1063 | if (stbi__bmp_test(s)) return stbi__bmp_load(s,x,y,comp,req_comp, ri); | ||
1064 | #endif | ||
1065 | #ifndef STBI_NO_GIF | ||
1066 | if (stbi__gif_test(s)) return stbi__gif_load(s,x,y,comp,req_comp, ri); | ||
1067 | #endif | ||
1068 | #ifndef STBI_NO_PSD | ||
1069 | if (stbi__psd_test(s)) return stbi__psd_load(s,x,y,comp,req_comp, ri, bpc); | ||
1070 | #else | ||
1071 | STBI_NOTUSED(bpc); | ||
1072 | #endif | ||
1073 | #ifndef STBI_NO_PIC | ||
1074 | if (stbi__pic_test(s)) return stbi__pic_load(s,x,y,comp,req_comp, ri); | ||
1075 | #endif | ||
1076 | #ifndef STBI_NO_PNM | ||
1077 | if (stbi__pnm_test(s)) return stbi__pnm_load(s,x,y,comp,req_comp, ri); | ||
1078 | #endif | ||
1079 | |||
1080 | #ifndef STBI_NO_HDR | ||
1081 | if (stbi__hdr_test(s)) { | ||
1082 | float *hdr = stbi__hdr_load(s, x,y,comp,req_comp, ri); | ||
1083 | return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp); | ||
1084 | } | ||
1085 | #endif | ||
1086 | |||
1087 | #ifndef STBI_NO_TGA | ||
1088 | // test tga last because it's a crappy test! | ||
1089 | if (stbi__tga_test(s)) | ||
1090 | return stbi__tga_load(s,x,y,comp,req_comp, ri); | ||
1091 | #endif | ||
1092 | |||
1093 | return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt"); | ||
1094 | } | ||
1095 | |||
1096 | static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels) | ||
1097 | { | ||
1098 | int i; | ||
1099 | int img_len = w * h * channels; | ||
1100 | stbi_uc *reduced; | ||
1101 | |||
1102 | reduced = (stbi_uc *) stbi__malloc(img_len); | ||
1103 | if (reduced == NULL) return stbi__errpuc("outofmem", "Out of memory"); | ||
1104 | |||
1105 | for (i = 0; i < img_len; ++i) | ||
1106 | reduced[i] = (stbi_uc)((orig[i] >> 8) & 0xFF); // top half of each byte is sufficient approx of 16->8 bit scaling | ||
1107 | |||
1108 | STBI_FREE(orig); | ||
1109 | return reduced; | ||
1110 | } | ||
1111 | |||
1112 | static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels) | ||
1113 | { | ||
1114 | int i; | ||
1115 | int img_len = w * h * channels; | ||
1116 | stbi__uint16 *enlarged; | ||
1117 | |||
1118 | enlarged = (stbi__uint16 *) stbi__malloc(img_len*2); | ||
1119 | if (enlarged == NULL) return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); | ||
1120 | |||
1121 | for (i = 0; i < img_len; ++i) | ||
1122 | enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]); // replicate to high and low byte, maps 0->0, 255->0xffff | ||
1123 | |||
1124 | STBI_FREE(orig); | ||
1125 | return enlarged; | ||
1126 | } | ||
1127 | |||
1128 | static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel) | ||
1129 | { | ||
1130 | int row; | ||
1131 | size_t bytes_per_row = (size_t)w * bytes_per_pixel; | ||
1132 | stbi_uc temp[2048]; | ||
1133 | stbi_uc *bytes = (stbi_uc *)image; | ||
1134 | |||
1135 | for (row = 0; row < (h>>1); row++) { | ||
1136 | stbi_uc *row0 = bytes + row*bytes_per_row; | ||
1137 | stbi_uc *row1 = bytes + (h - row - 1)*bytes_per_row; | ||
1138 | // swap row0 with row1 | ||
1139 | size_t bytes_left = bytes_per_row; | ||
1140 | while (bytes_left) { | ||
1141 | size_t bytes_copy = (bytes_left < sizeof(temp)) ? bytes_left : sizeof(temp); | ||
1142 | memcpy(temp, row0, bytes_copy); | ||
1143 | memcpy(row0, row1, bytes_copy); | ||
1144 | memcpy(row1, temp, bytes_copy); | ||
1145 | row0 += bytes_copy; | ||
1146 | row1 += bytes_copy; | ||
1147 | bytes_left -= bytes_copy; | ||
1148 | } | ||
1149 | } | ||
1150 | } | ||
1151 | |||
1152 | #ifndef STBI_NO_GIF | ||
1153 | static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel) | ||
1154 | { | ||
1155 | int slice; | ||
1156 | int slice_size = w * h * bytes_per_pixel; | ||
1157 | |||
1158 | stbi_uc *bytes = (stbi_uc *)image; | ||
1159 | for (slice = 0; slice < z; ++slice) { | ||
1160 | stbi__vertical_flip(bytes, w, h, bytes_per_pixel); | ||
1161 | bytes += slice_size; | ||
1162 | } | ||
1163 | } | ||
1164 | #endif | ||
1165 | |||
1166 | static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp) | ||
1167 | { | ||
1168 | stbi__result_info ri; | ||
1169 | void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8); | ||
1170 | |||
1171 | if (result == NULL) | ||
1172 | return NULL; | ||
1173 | |||
1174 | if (ri.bits_per_channel != 8) { | ||
1175 | STBI_ASSERT(ri.bits_per_channel == 16); | ||
1176 | result = stbi__convert_16_to_8((stbi__uint16 *) result, *x, *y, req_comp == 0 ? *comp : req_comp); | ||
1177 | ri.bits_per_channel = 8; | ||
1178 | } | ||
1179 | |||
1180 | // @TODO: move stbi__convert_format to here | ||
1181 | |||
1182 | if (stbi__vertically_flip_on_load) { | ||
1183 | int channels = req_comp ? req_comp : *comp; | ||
1184 | stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi_uc)); | ||
1185 | } | ||
1186 | |||
1187 | return (unsigned char *) result; | ||
1188 | } | ||
1189 | |||
1190 | static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp) | ||
1191 | { | ||
1192 | stbi__result_info ri; | ||
1193 | void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16); | ||
1194 | |||
1195 | if (result == NULL) | ||
1196 | return NULL; | ||
1197 | |||
1198 | if (ri.bits_per_channel != 16) { | ||
1199 | STBI_ASSERT(ri.bits_per_channel == 8); | ||
1200 | result = stbi__convert_8_to_16((stbi_uc *) result, *x, *y, req_comp == 0 ? *comp : req_comp); | ||
1201 | ri.bits_per_channel = 16; | ||
1202 | } | ||
1203 | |||
1204 | // @TODO: move stbi__convert_format16 to here | ||
1205 | // @TODO: special case RGB-to-Y (and RGBA-to-YA) for 8-bit-to-16-bit case to keep more precision | ||
1206 | |||
1207 | if (stbi__vertically_flip_on_load) { | ||
1208 | int channels = req_comp ? req_comp : *comp; | ||
1209 | stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi__uint16)); | ||
1210 | } | ||
1211 | |||
1212 | return (stbi__uint16 *) result; | ||
1213 | } | ||
1214 | |||
1215 | #if !defined(STBI_NO_HDR) && !defined(STBI_NO_LINEAR) | ||
1216 | static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp) | ||
1217 | { | ||
1218 | if (stbi__vertically_flip_on_load && result != NULL) { | ||
1219 | int channels = req_comp ? req_comp : *comp; | ||
1220 | stbi__vertical_flip(result, *x, *y, channels * sizeof(float)); | ||
1221 | } | ||
1222 | } | ||
1223 | #endif | ||
1224 | |||
1225 | #ifndef STBI_NO_STDIO | ||
1226 | |||
1227 | #if defined(_MSC_VER) && defined(STBI_WINDOWS_UTF8) | ||
1228 | STBI_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide); | ||
1229 | STBI_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); | ||
1230 | #endif | ||
1231 | |||
1232 | #if defined(_MSC_VER) && defined(STBI_WINDOWS_UTF8) | ||
1233 | STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input) | ||
1234 | { | ||
1235 | return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL); | ||
1236 | } | ||
1237 | #endif | ||
1238 | |||
1239 | static FILE *stbi__fopen(char const *filename, char const *mode) | ||
1240 | { | ||
1241 | FILE *f; | ||
1242 | #if defined(_MSC_VER) && defined(STBI_WINDOWS_UTF8) | ||
1243 | wchar_t wMode[64]; | ||
1244 | wchar_t wFilename[1024]; | ||
1245 | if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename))) | ||
1246 | return 0; | ||
1247 | |||
1248 | if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode))) | ||
1249 | return 0; | ||
1250 | |||
1251 | #if _MSC_VER >= 1400 | ||
1252 | if (0 != _wfopen_s(&f, wFilename, wMode)) | ||
1253 | f = 0; | ||
1254 | #else | ||
1255 | f = _wfopen(wFilename, wMode); | ||
1256 | #endif | ||
1257 | |||
1258 | #elif defined(_MSC_VER) && _MSC_VER >= 1400 | ||
1259 | if (0 != fopen_s(&f, filename, mode)) | ||
1260 | f=0; | ||
1261 | #else | ||
1262 | f = fopen(filename, mode); | ||
1263 | #endif | ||
1264 | return f; | ||
1265 | } | ||
1266 | |||
1267 | |||
1268 | STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp) | ||
1269 | { | ||
1270 | FILE *f = stbi__fopen(filename, "rb"); | ||
1271 | unsigned char *result; | ||
1272 | if (!f) return stbi__errpuc("can't fopen", "Unable to open file"); | ||
1273 | result = stbi_load_from_file(f,x,y,comp,req_comp); | ||
1274 | fclose(f); | ||
1275 | return result; | ||
1276 | } | ||
1277 | |||
1278 | STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) | ||
1279 | { | ||
1280 | unsigned char *result; | ||
1281 | stbi__context s; | ||
1282 | stbi__start_file(&s,f); | ||
1283 | result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); | ||
1284 | if (result) { | ||
1285 | // need to 'unget' all the characters in the IO buffer | ||
1286 | fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR); | ||
1287 | } | ||
1288 | return result; | ||
1289 | } | ||
1290 | |||
1291 | STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp) | ||
1292 | { | ||
1293 | stbi__uint16 *result; | ||
1294 | stbi__context s; | ||
1295 | stbi__start_file(&s,f); | ||
1296 | result = stbi__load_and_postprocess_16bit(&s,x,y,comp,req_comp); | ||
1297 | if (result) { | ||
1298 | // need to 'unget' all the characters in the IO buffer | ||
1299 | fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR); | ||
1300 | } | ||
1301 | return result; | ||
1302 | } | ||
1303 | |||
1304 | STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp) | ||
1305 | { | ||
1306 | FILE *f = stbi__fopen(filename, "rb"); | ||
1307 | stbi__uint16 *result; | ||
1308 | if (!f) return (stbi_us *) stbi__errpuc("can't fopen", "Unable to open file"); | ||
1309 | result = stbi_load_from_file_16(f,x,y,comp,req_comp); | ||
1310 | fclose(f); | ||
1311 | return result; | ||
1312 | } | ||
1313 | |||
1314 | |||
1315 | #endif //!STBI_NO_STDIO | ||
1316 | |||
1317 | STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels) | ||
1318 | { | ||
1319 | stbi__context s; | ||
1320 | stbi__start_mem(&s,buffer,len); | ||
1321 | return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels); | ||
1322 | } | ||
1323 | |||
1324 | STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels) | ||
1325 | { | ||
1326 | stbi__context s; | ||
1327 | stbi__start_callbacks(&s, (stbi_io_callbacks *)clbk, user); | ||
1328 | return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels); | ||
1329 | } | ||
1330 | |||
1331 | STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) | ||
1332 | { | ||
1333 | stbi__context s; | ||
1334 | stbi__start_mem(&s,buffer,len); | ||
1335 | return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); | ||
1336 | } | ||
1337 | |||
1338 | STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) | ||
1339 | { | ||
1340 | stbi__context s; | ||
1341 | stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); | ||
1342 | return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); | ||
1343 | } | ||
1344 | |||
1345 | #ifndef STBI_NO_GIF | ||
1346 | STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp) | ||
1347 | { | ||
1348 | unsigned char *result; | ||
1349 | stbi__context s; | ||
1350 | stbi__start_mem(&s,buffer,len); | ||
1351 | |||
1352 | result = (unsigned char*) stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp); | ||
1353 | if (stbi__vertically_flip_on_load) { | ||
1354 | stbi__vertical_flip_slices( result, *x, *y, *z, *comp ); | ||
1355 | } | ||
1356 | |||
1357 | return result; | ||
1358 | } | ||
1359 | #endif | ||
1360 | |||
1361 | #ifndef STBI_NO_LINEAR | ||
1362 | static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp) | ||
1363 | { | ||
1364 | unsigned char *data; | ||
1365 | #ifndef STBI_NO_HDR | ||
1366 | if (stbi__hdr_test(s)) { | ||
1367 | stbi__result_info ri; | ||
1368 | float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp, &ri); | ||
1369 | if (hdr_data) | ||
1370 | stbi__float_postprocess(hdr_data,x,y,comp,req_comp); | ||
1371 | return hdr_data; | ||
1372 | } | ||
1373 | #endif | ||
1374 | data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp); | ||
1375 | if (data) | ||
1376 | return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp); | ||
1377 | return stbi__errpf("unknown image type", "Image not of any known type, or corrupt"); | ||
1378 | } | ||
1379 | |||
1380 | STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) | ||
1381 | { | ||
1382 | stbi__context s; | ||
1383 | stbi__start_mem(&s,buffer,len); | ||
1384 | return stbi__loadf_main(&s,x,y,comp,req_comp); | ||
1385 | } | ||
1386 | |||
1387 | STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) | ||
1388 | { | ||
1389 | stbi__context s; | ||
1390 | stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); | ||
1391 | return stbi__loadf_main(&s,x,y,comp,req_comp); | ||
1392 | } | ||
1393 | |||
1394 | #ifndef STBI_NO_STDIO | ||
1395 | STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp) | ||
1396 | { | ||
1397 | float *result; | ||
1398 | FILE *f = stbi__fopen(filename, "rb"); | ||
1399 | if (!f) return stbi__errpf("can't fopen", "Unable to open file"); | ||
1400 | result = stbi_loadf_from_file(f,x,y,comp,req_comp); | ||
1401 | fclose(f); | ||
1402 | return result; | ||
1403 | } | ||
1404 | |||
1405 | STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) | ||
1406 | { | ||
1407 | stbi__context s; | ||
1408 | stbi__start_file(&s,f); | ||
1409 | return stbi__loadf_main(&s,x,y,comp,req_comp); | ||
1410 | } | ||
1411 | #endif // !STBI_NO_STDIO | ||
1412 | |||
1413 | #endif // !STBI_NO_LINEAR | ||
1414 | |||
1415 | // these is-hdr-or-not is defined independent of whether STBI_NO_LINEAR is | ||
1416 | // defined, for API simplicity; if STBI_NO_LINEAR is defined, it always | ||
1417 | // reports false! | ||
1418 | |||
1419 | STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len) | ||
1420 | { | ||
1421 | #ifndef STBI_NO_HDR | ||
1422 | stbi__context s; | ||
1423 | stbi__start_mem(&s,buffer,len); | ||
1424 | return stbi__hdr_test(&s); | ||
1425 | #else | ||
1426 | STBI_NOTUSED(buffer); | ||
1427 | STBI_NOTUSED(len); | ||
1428 | return 0; | ||
1429 | #endif | ||
1430 | } | ||
1431 | |||
1432 | #ifndef STBI_NO_STDIO | ||
1433 | STBIDEF int stbi_is_hdr (char const *filename) | ||
1434 | { | ||
1435 | FILE *f = stbi__fopen(filename, "rb"); | ||
1436 | int result=0; | ||
1437 | if (f) { | ||
1438 | result = stbi_is_hdr_from_file(f); | ||
1439 | fclose(f); | ||
1440 | } | ||
1441 | return result; | ||
1442 | } | ||
1443 | |||
1444 | STBIDEF int stbi_is_hdr_from_file(FILE *f) | ||
1445 | { | ||
1446 | #ifndef STBI_NO_HDR | ||
1447 | long pos = ftell(f); | ||
1448 | int res; | ||
1449 | stbi__context s; | ||
1450 | stbi__start_file(&s,f); | ||
1451 | res = stbi__hdr_test(&s); | ||
1452 | fseek(f, pos, SEEK_SET); | ||
1453 | return res; | ||
1454 | #else | ||
1455 | STBI_NOTUSED(f); | ||
1456 | return 0; | ||
1457 | #endif | ||
1458 | } | ||
1459 | #endif // !STBI_NO_STDIO | ||
1460 | |||
1461 | STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user) | ||
1462 | { | ||
1463 | #ifndef STBI_NO_HDR | ||
1464 | stbi__context s; | ||
1465 | stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); | ||
1466 | return stbi__hdr_test(&s); | ||
1467 | #else | ||
1468 | STBI_NOTUSED(clbk); | ||
1469 | STBI_NOTUSED(user); | ||
1470 | return 0; | ||
1471 | #endif | ||
1472 | } | ||
1473 | |||
1474 | #ifndef STBI_NO_LINEAR | ||
1475 | static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f; | ||
1476 | |||
1477 | STBIDEF void stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; } | ||
1478 | STBIDEF void stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; } | ||
1479 | #endif | ||
1480 | |||
1481 | static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f; | ||
1482 | |||
1483 | STBIDEF void stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; } | ||
1484 | STBIDEF void stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; } | ||
1485 | |||
1486 | |||
1487 | ////////////////////////////////////////////////////////////////////////////// | ||
1488 | // | ||
1489 | // Common code used by all image loaders | ||
1490 | // | ||
1491 | |||
1492 | enum | ||
1493 | { | ||
1494 | STBI__SCAN_load=0, | ||
1495 | STBI__SCAN_type, | ||
1496 | STBI__SCAN_header | ||
1497 | }; | ||
1498 | |||
1499 | static void stbi__refill_buffer(stbi__context *s) | ||
1500 | { | ||
1501 | int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen); | ||
1502 | if (n == 0) { | ||
1503 | // at end of file, treat same as if from memory, but need to handle case | ||
1504 | // where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file | ||
1505 | s->read_from_callbacks = 0; | ||
1506 | s->img_buffer = s->buffer_start; | ||
1507 | s->img_buffer_end = s->buffer_start+1; | ||
1508 | *s->img_buffer = 0; | ||
1509 | } else { | ||
1510 | s->img_buffer = s->buffer_start; | ||
1511 | s->img_buffer_end = s->buffer_start + n; | ||
1512 | } | ||
1513 | } | ||
1514 | |||
1515 | stbi_inline static stbi_uc stbi__get8(stbi__context *s) | ||
1516 | { | ||
1517 | if (s->img_buffer < s->img_buffer_end) | ||
1518 | return *s->img_buffer++; | ||
1519 | if (s->read_from_callbacks) { | ||
1520 | stbi__refill_buffer(s); | ||
1521 | return *s->img_buffer++; | ||
1522 | } | ||
1523 | return 0; | ||
1524 | } | ||
1525 | |||
1526 | #if defined(STBI_NO_JPEG) && defined(STBI_NO_HDR) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) | ||
1527 | // nothing | ||
1528 | #else | ||
1529 | stbi_inline static int stbi__at_eof(stbi__context *s) | ||
1530 | { | ||
1531 | if (s->io.read) { | ||
1532 | if (!(s->io.eof)(s->io_user_data)) return 0; | ||
1533 | // if feof() is true, check if buffer = end | ||
1534 | // special case: we've only got the special 0 character at the end | ||
1535 | if (s->read_from_callbacks == 0) return 1; | ||
1536 | } | ||
1537 | |||
1538 | return s->img_buffer >= s->img_buffer_end; | ||
1539 | } | ||
1540 | #endif | ||
1541 | |||
1542 | #if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) | ||
1543 | // nothing | ||
1544 | #else | ||
1545 | static void stbi__skip(stbi__context *s, int n) | ||
1546 | { | ||
1547 | if (n < 0) { | ||
1548 | s->img_buffer = s->img_buffer_end; | ||
1549 | return; | ||
1550 | } | ||
1551 | if (s->io.read) { | ||
1552 | int blen = (int) (s->img_buffer_end - s->img_buffer); | ||
1553 | if (blen < n) { | ||
1554 | s->img_buffer = s->img_buffer_end; | ||
1555 | (s->io.skip)(s->io_user_data, n - blen); | ||
1556 | return; | ||
1557 | } | ||
1558 | } | ||
1559 | s->img_buffer += n; | ||
1560 | } | ||
1561 | #endif | ||
1562 | |||
1563 | #if defined(STBI_NO_PNG) && defined(STBI_NO_TGA) && defined(STBI_NO_HDR) && defined(STBI_NO_PNM) | ||
1564 | // nothing | ||
1565 | #else | ||
1566 | static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n) | ||
1567 | { | ||
1568 | if (s->io.read) { | ||
1569 | int blen = (int) (s->img_buffer_end - s->img_buffer); | ||
1570 | if (blen < n) { | ||
1571 | int res, count; | ||
1572 | |||
1573 | memcpy(buffer, s->img_buffer, blen); | ||
1574 | |||
1575 | count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen); | ||
1576 | res = (count == (n-blen)); | ||
1577 | s->img_buffer = s->img_buffer_end; | ||
1578 | return res; | ||
1579 | } | ||
1580 | } | ||
1581 | |||
1582 | if (s->img_buffer+n <= s->img_buffer_end) { | ||
1583 | memcpy(buffer, s->img_buffer, n); | ||
1584 | s->img_buffer += n; | ||
1585 | return 1; | ||
1586 | } else | ||
1587 | return 0; | ||
1588 | } | ||
1589 | #endif | ||
1590 | |||
1591 | #if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC) | ||
1592 | // nothing | ||
1593 | #else | ||
1594 | static int stbi__get16be(stbi__context *s) | ||
1595 | { | ||
1596 | int z = stbi__get8(s); | ||
1597 | return (z << 8) + stbi__get8(s); | ||
1598 | } | ||
1599 | #endif | ||
1600 | |||
1601 | #if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC) | ||
1602 | // nothing | ||
1603 | #else | ||
1604 | static stbi__uint32 stbi__get32be(stbi__context *s) | ||
1605 | { | ||
1606 | stbi__uint32 z = stbi__get16be(s); | ||
1607 | return (z << 16) + stbi__get16be(s); | ||
1608 | } | ||
1609 | #endif | ||
1610 | |||
1611 | #if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) | ||
1612 | // nothing | ||
1613 | #else | ||
1614 | static int stbi__get16le(stbi__context *s) | ||
1615 | { | ||
1616 | int z = stbi__get8(s); | ||
1617 | return z + (stbi__get8(s) << 8); | ||
1618 | } | ||
1619 | #endif | ||
1620 | |||
1621 | #ifndef STBI_NO_BMP | ||
1622 | static stbi__uint32 stbi__get32le(stbi__context *s) | ||
1623 | { | ||
1624 | stbi__uint32 z = stbi__get16le(s); | ||
1625 | return z + (stbi__get16le(s) << 16); | ||
1626 | } | ||
1627 | #endif | ||
1628 | |||
1629 | #define STBI__BYTECAST(x) ((stbi_uc) ((x) & 255)) // truncate int to byte without warnings | ||
1630 | |||
1631 | #if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) | ||
1632 | // nothing | ||
1633 | #else | ||
1634 | ////////////////////////////////////////////////////////////////////////////// | ||
1635 | // | ||
1636 | // generic converter from built-in img_n to req_comp | ||
1637 | // individual types do this automatically as much as possible (e.g. jpeg | ||
1638 | // does all cases internally since it needs to colorspace convert anyway, | ||
1639 | // and it never has alpha, so very few cases ). png can automatically | ||
1640 | // interleave an alpha=255 channel, but falls back to this for other cases | ||
1641 | // | ||
1642 | // assume data buffer is malloced, so malloc a new one and free that one | ||
1643 | // only failure mode is malloc failing | ||
1644 | |||
1645 | static stbi_uc stbi__compute_y(int r, int g, int b) | ||
1646 | { | ||
1647 | return (stbi_uc) (((r*77) + (g*150) + (29*b)) >> 8); | ||
1648 | } | ||
1649 | #endif | ||
1650 | |||
1651 | #if defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) | ||
1652 | // nothing | ||
1653 | #else | ||
1654 | static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y) | ||
1655 | { | ||
1656 | int i,j; | ||
1657 | unsigned char *good; | ||
1658 | |||
1659 | if (req_comp == img_n) return data; | ||
1660 | STBI_ASSERT(req_comp >= 1 && req_comp <= 4); | ||
1661 | |||
1662 | good = (unsigned char *) stbi__malloc_mad3(req_comp, x, y, 0); | ||
1663 | if (good == NULL) { | ||
1664 | STBI_FREE(data); | ||
1665 | return stbi__errpuc("outofmem", "Out of memory"); | ||
1666 | } | ||
1667 | |||
1668 | for (j=0; j < (int) y; ++j) { | ||
1669 | unsigned char *src = data + j * x * img_n ; | ||
1670 | unsigned char *dest = good + j * x * req_comp; | ||
1671 | |||
1672 | #define STBI__COMBO(a,b) ((a)*8+(b)) | ||
1673 | #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) | ||
1674 | // convert source image with img_n components to one with req_comp components; | ||
1675 | // avoid switch per pixel, so use switch per scanline and massive macros | ||
1676 | switch (STBI__COMBO(img_n, req_comp)) { | ||
1677 | STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=255; } break; | ||
1678 | STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; | ||
1679 | STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=255; } break; | ||
1680 | STBI__CASE(2,1) { dest[0]=src[0]; } break; | ||
1681 | STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; | ||
1682 | STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break; | ||
1683 | STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=255; } break; | ||
1684 | STBI__CASE(3,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break; | ||
1685 | STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = 255; } break; | ||
1686 | STBI__CASE(4,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break; | ||
1687 | STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = src[3]; } break; | ||
1688 | STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break; | ||
1689 | default: STBI_ASSERT(0); | ||
1690 | } | ||
1691 | #undef STBI__CASE | ||
1692 | } | ||
1693 | |||
1694 | STBI_FREE(data); | ||
1695 | return good; | ||
1696 | } | ||
1697 | #endif | ||
1698 | |||
1699 | #if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) | ||
1700 | // nothing | ||
1701 | #else | ||
1702 | static stbi__uint16 stbi__compute_y_16(int r, int g, int b) | ||
1703 | { | ||
1704 | return (stbi__uint16) (((r*77) + (g*150) + (29*b)) >> 8); | ||
1705 | } | ||
1706 | #endif | ||
1707 | |||
1708 | #if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) | ||
1709 | // nothing | ||
1710 | #else | ||
1711 | static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y) | ||
1712 | { | ||
1713 | int i,j; | ||
1714 | stbi__uint16 *good; | ||
1715 | |||
1716 | if (req_comp == img_n) return data; | ||
1717 | STBI_ASSERT(req_comp >= 1 && req_comp <= 4); | ||
1718 | |||
1719 | good = (stbi__uint16 *) stbi__malloc(req_comp * x * y * 2); | ||
1720 | if (good == NULL) { | ||
1721 | STBI_FREE(data); | ||
1722 | return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); | ||
1723 | } | ||
1724 | |||
1725 | for (j=0; j < (int) y; ++j) { | ||
1726 | stbi__uint16 *src = data + j * x * img_n ; | ||
1727 | stbi__uint16 *dest = good + j * x * req_comp; | ||
1728 | |||
1729 | #define STBI__COMBO(a,b) ((a)*8+(b)) | ||
1730 | #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) | ||
1731 | // convert source image with img_n components to one with req_comp components; | ||
1732 | // avoid switch per pixel, so use switch per scanline and massive macros | ||
1733 | switch (STBI__COMBO(img_n, req_comp)) { | ||
1734 | STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=0xffff; } break; | ||
1735 | STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; | ||
1736 | STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=0xffff; } break; | ||
1737 | STBI__CASE(2,1) { dest[0]=src[0]; } break; | ||
1738 | STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; | ||
1739 | STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break; | ||
1740 | STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=0xffff; } break; | ||
1741 | STBI__CASE(3,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break; | ||
1742 | STBI__CASE(3,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = 0xffff; } break; | ||
1743 | STBI__CASE(4,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break; | ||
1744 | STBI__CASE(4,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = src[3]; } break; | ||
1745 | STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break; | ||
1746 | default: STBI_ASSERT(0); | ||
1747 | } | ||
1748 | #undef STBI__CASE | ||
1749 | } | ||
1750 | |||
1751 | STBI_FREE(data); | ||
1752 | return good; | ||
1753 | } | ||
1754 | #endif | ||
1755 | |||
1756 | #ifndef STBI_NO_LINEAR | ||
1757 | static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp) | ||
1758 | { | ||
1759 | int i,k,n; | ||
1760 | float *output; | ||
1761 | if (!data) return NULL; | ||
1762 | output = (float *) stbi__malloc_mad4(x, y, comp, sizeof(float), 0); | ||
1763 | if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); } | ||
1764 | // compute number of non-alpha components | ||
1765 | if (comp & 1) n = comp; else n = comp-1; | ||
1766 | for (i=0; i < x*y; ++i) { | ||
1767 | for (k=0; k < n; ++k) { | ||
1768 | output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale); | ||
1769 | } | ||
1770 | } | ||
1771 | if (n < comp) { | ||
1772 | for (i=0; i < x*y; ++i) { | ||
1773 | output[i*comp + n] = data[i*comp + n]/255.0f; | ||
1774 | } | ||
1775 | } | ||
1776 | STBI_FREE(data); | ||
1777 | return output; | ||
1778 | } | ||
1779 | #endif | ||
1780 | |||
1781 | #ifndef STBI_NO_HDR | ||
1782 | #define stbi__float2int(x) ((int) (x)) | ||
1783 | static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp) | ||
1784 | { | ||
1785 | int i,k,n; | ||
1786 | stbi_uc *output; | ||
1787 | if (!data) return NULL; | ||
1788 | output = (stbi_uc *) stbi__malloc_mad3(x, y, comp, 0); | ||
1789 | if (output == NULL) { STBI_FREE(data); return stbi__errpuc("outofmem", "Out of memory"); } | ||
1790 | // compute number of non-alpha components | ||
1791 | if (comp & 1) n = comp; else n = comp-1; | ||
1792 | for (i=0; i < x*y; ++i) { | ||
1793 | for (k=0; k < n; ++k) { | ||
1794 | float z = (float) pow(data[i*comp+k]*stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f; | ||
1795 | if (z < 0) z = 0; | ||
1796 | if (z > 255) z = 255; | ||
1797 | output[i*comp + k] = (stbi_uc) stbi__float2int(z); | ||
1798 | } | ||
1799 | if (k < comp) { | ||
1800 | float z = data[i*comp+k] * 255 + 0.5f; | ||
1801 | if (z < 0) z = 0; | ||
1802 | if (z > 255) z = 255; | ||
1803 | output[i*comp + k] = (stbi_uc) stbi__float2int(z); | ||
1804 | } | ||
1805 | } | ||
1806 | STBI_FREE(data); | ||
1807 | return output; | ||
1808 | } | ||
1809 | #endif | ||
1810 | |||
1811 | ////////////////////////////////////////////////////////////////////////////// | ||
1812 | // | ||
1813 | // "baseline" JPEG/JFIF decoder | ||
1814 | // | ||
1815 | // simple implementation | ||
1816 | // - doesn't support delayed output of y-dimension | ||
1817 | // - simple interface (only one output format: 8-bit interleaved RGB) | ||
1818 | // - doesn't try to recover corrupt jpegs | ||
1819 | // - doesn't allow partial loading, loading multiple at once | ||
1820 | // - still fast on x86 (copying globals into locals doesn't help x86) | ||
1821 | // - allocates lots of intermediate memory (full size of all components) | ||
1822 | // - non-interleaved case requires this anyway | ||
1823 | // - allows good upsampling (see next) | ||
1824 | // high-quality | ||
1825 | // - upsampled channels are bilinearly interpolated, even across blocks | ||
1826 | // - quality integer IDCT derived from IJG's 'slow' | ||
1827 | // performance | ||
1828 | // - fast huffman; reasonable integer IDCT | ||
1829 | // - some SIMD kernels for common paths on targets with SSE2/NEON | ||
1830 | // - uses a lot of intermediate memory, could cache poorly | ||
1831 | |||
1832 | #ifndef STBI_NO_JPEG | ||
1833 | |||
1834 | // huffman decoding acceleration | ||
1835 | #define FAST_BITS 9 // larger handles more cases; smaller stomps less cache | ||
1836 | |||
1837 | typedef struct | ||
1838 | { | ||
1839 | stbi_uc fast[1 << FAST_BITS]; | ||
1840 | // weirdly, repacking this into AoS is a 10% speed loss, instead of a win | ||
1841 | stbi__uint16 code[256]; | ||
1842 | stbi_uc values[256]; | ||
1843 | stbi_uc size[257]; | ||
1844 | unsigned int maxcode[18]; | ||
1845 | int delta[17]; // old 'firstsymbol' - old 'firstcode' | ||
1846 | } stbi__huffman; | ||
1847 | |||
1848 | typedef struct | ||
1849 | { | ||
1850 | stbi__context *s; | ||
1851 | stbi__huffman huff_dc[4]; | ||
1852 | stbi__huffman huff_ac[4]; | ||
1853 | stbi__uint16 dequant[4][64]; | ||
1854 | stbi__int16 fast_ac[4][1 << FAST_BITS]; | ||
1855 | |||
1856 | // sizes for components, interleaved MCUs | ||
1857 | int img_h_max, img_v_max; | ||
1858 | int img_mcu_x, img_mcu_y; | ||
1859 | int img_mcu_w, img_mcu_h; | ||
1860 | |||
1861 | // definition of jpeg image component | ||
1862 | struct | ||
1863 | { | ||
1864 | int id; | ||
1865 | int h,v; | ||
1866 | int tq; | ||
1867 | int hd,ha; | ||
1868 | int dc_pred; | ||
1869 | |||
1870 | int x,y,w2,h2; | ||
1871 | stbi_uc *data; | ||
1872 | void *raw_data, *raw_coeff; | ||
1873 | stbi_uc *linebuf; | ||
1874 | short *coeff; // progressive only | ||
1875 | int coeff_w, coeff_h; // number of 8x8 coefficient blocks | ||
1876 | } img_comp[4]; | ||
1877 | |||
1878 | stbi__uint32 code_buffer; // jpeg entropy-coded buffer | ||
1879 | int code_bits; // number of valid bits | ||
1880 | unsigned char marker; // marker seen while filling entropy buffer | ||
1881 | int nomore; // flag if we saw a marker so must stop | ||
1882 | |||
1883 | int progressive; | ||
1884 | int spec_start; | ||
1885 | int spec_end; | ||
1886 | int succ_high; | ||
1887 | int succ_low; | ||
1888 | int eob_run; | ||
1889 | int jfif; | ||
1890 | int app14_color_transform; // Adobe APP14 tag | ||
1891 | int rgb; | ||
1892 | |||
1893 | int scan_n, order[4]; | ||
1894 | int restart_interval, todo; | ||
1895 | |||
1896 | // kernels | ||
1897 | void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]); | ||
1898 | void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step); | ||
1899 | stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs); | ||
1900 | } stbi__jpeg; | ||
1901 | |||
1902 | static int stbi__build_huffman(stbi__huffman *h, int *count) | ||
1903 | { | ||
1904 | int i,j,k=0; | ||
1905 | unsigned int code; | ||
1906 | // build size list for each symbol (from JPEG spec) | ||
1907 | for (i=0; i < 16; ++i) | ||
1908 | for (j=0; j < count[i]; ++j) | ||
1909 | h->size[k++] = (stbi_uc) (i+1); | ||
1910 | h->size[k] = 0; | ||
1911 | |||
1912 | // compute actual symbols (from jpeg spec) | ||
1913 | code = 0; | ||
1914 | k = 0; | ||
1915 | for(j=1; j <= 16; ++j) { | ||
1916 | // compute delta to add to code to compute symbol id | ||
1917 | h->delta[j] = k - code; | ||
1918 | if (h->size[k] == j) { | ||
1919 | while (h->size[k] == j) | ||
1920 | h->code[k++] = (stbi__uint16) (code++); | ||
1921 | if (code-1 >= (1u << j)) return stbi__err("bad code lengths","Corrupt JPEG"); | ||
1922 | } | ||
1923 | // compute largest code + 1 for this size, preshifted as needed later | ||
1924 | h->maxcode[j] = code << (16-j); | ||
1925 | code <<= 1; | ||
1926 | } | ||
1927 | h->maxcode[j] = 0xffffffff; | ||
1928 | |||
1929 | // build non-spec acceleration table; 255 is flag for not-accelerated | ||
1930 | memset(h->fast, 255, 1 << FAST_BITS); | ||
1931 | for (i=0; i < k; ++i) { | ||
1932 | int s = h->size[i]; | ||
1933 | if (s <= FAST_BITS) { | ||
1934 | int c = h->code[i] << (FAST_BITS-s); | ||
1935 | int m = 1 << (FAST_BITS-s); | ||
1936 | for (j=0; j < m; ++j) { | ||
1937 | h->fast[c+j] = (stbi_uc) i; | ||
1938 | } | ||
1939 | } | ||
1940 | } | ||
1941 | return 1; | ||
1942 | } | ||
1943 | |||
1944 | // build a table that decodes both magnitude and value of small ACs in | ||
1945 | // one go. | ||
1946 | static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h) | ||
1947 | { | ||
1948 | int i; | ||
1949 | for (i=0; i < (1 << FAST_BITS); ++i) { | ||
1950 | stbi_uc fast = h->fast[i]; | ||
1951 | fast_ac[i] = 0; | ||
1952 | if (fast < 255) { | ||
1953 | int rs = h->values[fast]; | ||
1954 | int run = (rs >> 4) & 15; | ||
1955 | int magbits = rs & 15; | ||
1956 | int len = h->size[fast]; | ||
1957 | |||
1958 | if (magbits && len + magbits <= FAST_BITS) { | ||
1959 | // magnitude code followed by receive_extend code | ||
1960 | int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits); | ||
1961 | int m = 1 << (magbits - 1); | ||
1962 | if (k < m) k += (~0U << magbits) + 1; | ||
1963 | // if the result is small enough, we can fit it in fast_ac table | ||
1964 | if (k >= -128 && k <= 127) | ||
1965 | fast_ac[i] = (stbi__int16) ((k * 256) + (run * 16) + (len + magbits)); | ||
1966 | } | ||
1967 | } | ||
1968 | } | ||
1969 | } | ||
1970 | |||
1971 | static void stbi__grow_buffer_unsafe(stbi__jpeg *j) | ||
1972 | { | ||
1973 | do { | ||
1974 | unsigned int b = j->nomore ? 0 : stbi__get8(j->s); | ||
1975 | if (b == 0xff) { | ||
1976 | int c = stbi__get8(j->s); | ||
1977 | while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes | ||
1978 | if (c != 0) { | ||
1979 | j->marker = (unsigned char) c; | ||
1980 | j->nomore = 1; | ||
1981 | return; | ||
1982 | } | ||
1983 | } | ||
1984 | j->code_buffer |= b << (24 - j->code_bits); | ||
1985 | j->code_bits += 8; | ||
1986 | } while (j->code_bits <= 24); | ||
1987 | } | ||
1988 | |||
1989 | // (1 << n) - 1 | ||
1990 | static const stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535}; | ||
1991 | |||
1992 | // decode a jpeg huffman value from the bitstream | ||
1993 | stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h) | ||
1994 | { | ||
1995 | unsigned int temp; | ||
1996 | int c,k; | ||
1997 | |||
1998 | if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); | ||
1999 | |||
2000 | // look at the top FAST_BITS and determine what symbol ID it is, | ||
2001 | // if the code is <= FAST_BITS | ||
2002 | c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); | ||
2003 | k = h->fast[c]; | ||
2004 | if (k < 255) { | ||
2005 | int s = h->size[k]; | ||
2006 | if (s > j->code_bits) | ||
2007 | return -1; | ||
2008 | j->code_buffer <<= s; | ||
2009 | j->code_bits -= s; | ||
2010 | return h->values[k]; | ||
2011 | } | ||
2012 | |||
2013 | // naive test is to shift the code_buffer down so k bits are | ||
2014 | // valid, then test against maxcode. To speed this up, we've | ||
2015 | // preshifted maxcode left so that it has (16-k) 0s at the | ||
2016 | // end; in other words, regardless of the number of bits, it | ||
2017 | // wants to be compared against something shifted to have 16; | ||
2018 | // that way we don't need to shift inside the loop. | ||
2019 | temp = j->code_buffer >> 16; | ||
2020 | for (k=FAST_BITS+1 ; ; ++k) | ||
2021 | if (temp < h->maxcode[k]) | ||
2022 | break; | ||
2023 | if (k == 17) { | ||
2024 | // error! code not found | ||
2025 | j->code_bits -= 16; | ||
2026 | return -1; | ||
2027 | } | ||
2028 | |||
2029 | if (k > j->code_bits) | ||
2030 | return -1; | ||
2031 | |||
2032 | // convert the huffman code to the symbol id | ||
2033 | c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k]; | ||
2034 | STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]); | ||
2035 | |||
2036 | // convert the id to a symbol | ||
2037 | j->code_bits -= k; | ||
2038 | j->code_buffer <<= k; | ||
2039 | return h->values[c]; | ||
2040 | } | ||
2041 | |||
2042 | // bias[n] = (-1<<n) + 1 | ||
2043 | static const int stbi__jbias[16] = {0,-1,-3,-7,-15,-31,-63,-127,-255,-511,-1023,-2047,-4095,-8191,-16383,-32767}; | ||
2044 | |||
2045 | // combined JPEG 'receive' and JPEG 'extend', since baseline | ||
2046 | // always extends everything it receives. | ||
2047 | stbi_inline static int stbi__extend_receive(stbi__jpeg *j, int n) | ||
2048 | { | ||
2049 | unsigned int k; | ||
2050 | int sgn; | ||
2051 | if (j->code_bits < n) stbi__grow_buffer_unsafe(j); | ||
2052 | |||
2053 | sgn = (stbi__int32)j->code_buffer >> 31; // sign bit is always in MSB | ||
2054 | k = stbi_lrot(j->code_buffer, n); | ||
2055 | STBI_ASSERT(n >= 0 && n < (int) (sizeof(stbi__bmask)/sizeof(*stbi__bmask))); | ||
2056 | j->code_buffer = k & ~stbi__bmask[n]; | ||
2057 | k &= stbi__bmask[n]; | ||
2058 | j->code_bits -= n; | ||
2059 | return k + (stbi__jbias[n] & ~sgn); | ||
2060 | } | ||
2061 | |||
2062 | // get some unsigned bits | ||
2063 | stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n) | ||
2064 | { | ||
2065 | unsigned int k; | ||
2066 | if (j->code_bits < n) stbi__grow_buffer_unsafe(j); | ||
2067 | k = stbi_lrot(j->code_buffer, n); | ||
2068 | j->code_buffer = k & ~stbi__bmask[n]; | ||
2069 | k &= stbi__bmask[n]; | ||
2070 | j->code_bits -= n; | ||
2071 | return k; | ||
2072 | } | ||
2073 | |||
2074 | stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j) | ||
2075 | { | ||
2076 | unsigned int k; | ||
2077 | if (j->code_bits < 1) stbi__grow_buffer_unsafe(j); | ||
2078 | k = j->code_buffer; | ||
2079 | j->code_buffer <<= 1; | ||
2080 | --j->code_bits; | ||
2081 | return k & 0x80000000; | ||
2082 | } | ||
2083 | |||
2084 | // given a value that's at position X in the zigzag stream, | ||
2085 | // where does it appear in the 8x8 matrix coded as row-major? | ||
2086 | static const stbi_uc stbi__jpeg_dezigzag[64+15] = | ||
2087 | { | ||
2088 | 0, 1, 8, 16, 9, 2, 3, 10, | ||
2089 | 17, 24, 32, 25, 18, 11, 4, 5, | ||
2090 | 12, 19, 26, 33, 40, 48, 41, 34, | ||
2091 | 27, 20, 13, 6, 7, 14, 21, 28, | ||
2092 | 35, 42, 49, 56, 57, 50, 43, 36, | ||
2093 | 29, 22, 15, 23, 30, 37, 44, 51, | ||
2094 | 58, 59, 52, 45, 38, 31, 39, 46, | ||
2095 | 53, 60, 61, 54, 47, 55, 62, 63, | ||
2096 | // let corrupt input sample past end | ||
2097 | 63, 63, 63, 63, 63, 63, 63, 63, | ||
2098 | 63, 63, 63, 63, 63, 63, 63 | ||
2099 | }; | ||
2100 | |||
2101 | // decode one 64-entry block-- | ||
2102 | static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi__uint16 *dequant) | ||
2103 | { | ||
2104 | int diff,dc,k; | ||
2105 | int t; | ||
2106 | |||
2107 | if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); | ||
2108 | t = stbi__jpeg_huff_decode(j, hdc); | ||
2109 | if (t < 0) return stbi__err("bad huffman code","Corrupt JPEG"); | ||
2110 | |||
2111 | // 0 all the ac values now so we can do it 32-bits at a time | ||
2112 | memset(data,0,64*sizeof(data[0])); | ||
2113 | |||
2114 | diff = t ? stbi__extend_receive(j, t) : 0; | ||
2115 | dc = j->img_comp[b].dc_pred + diff; | ||
2116 | j->img_comp[b].dc_pred = dc; | ||
2117 | data[0] = (short) (dc * dequant[0]); | ||
2118 | |||
2119 | // decode AC components, see JPEG spec | ||
2120 | k = 1; | ||
2121 | do { | ||
2122 | unsigned int zig; | ||
2123 | int c,r,s; | ||
2124 | if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); | ||
2125 | c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); | ||
2126 | r = fac[c]; | ||
2127 | if (r) { // fast-AC path | ||
2128 | k += (r >> 4) & 15; // run | ||
2129 | s = r & 15; // combined length | ||
2130 | j->code_buffer <<= s; | ||
2131 | j->code_bits -= s; | ||
2132 | // decode into unzigzag'd location | ||
2133 | zig = stbi__jpeg_dezigzag[k++]; | ||
2134 | data[zig] = (short) ((r >> 8) * dequant[zig]); | ||
2135 | } else { | ||
2136 | int rs = stbi__jpeg_huff_decode(j, hac); | ||
2137 | if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); | ||
2138 | s = rs & 15; | ||
2139 | r = rs >> 4; | ||
2140 | if (s == 0) { | ||
2141 | if (rs != 0xf0) break; // end block | ||
2142 | k += 16; | ||
2143 | } else { | ||
2144 | k += r; | ||
2145 | // decode into unzigzag'd location | ||
2146 | zig = stbi__jpeg_dezigzag[k++]; | ||
2147 | data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]); | ||
2148 | } | ||
2149 | } | ||
2150 | } while (k < 64); | ||
2151 | return 1; | ||
2152 | } | ||
2153 | |||
2154 | static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b) | ||
2155 | { | ||
2156 | int diff,dc; | ||
2157 | int t; | ||
2158 | if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); | ||
2159 | |||
2160 | if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); | ||
2161 | |||
2162 | if (j->succ_high == 0) { | ||
2163 | // first scan for DC coefficient, must be first | ||
2164 | memset(data,0,64*sizeof(data[0])); // 0 all the ac values now | ||
2165 | t = stbi__jpeg_huff_decode(j, hdc); | ||
2166 | diff = t ? stbi__extend_receive(j, t) : 0; | ||
2167 | |||
2168 | dc = j->img_comp[b].dc_pred + diff; | ||
2169 | j->img_comp[b].dc_pred = dc; | ||
2170 | data[0] = (short) (dc << j->succ_low); | ||
2171 | } else { | ||
2172 | // refinement scan for DC coefficient | ||
2173 | if (stbi__jpeg_get_bit(j)) | ||
2174 | data[0] += (short) (1 << j->succ_low); | ||
2175 | } | ||
2176 | return 1; | ||
2177 | } | ||
2178 | |||
2179 | // @OPTIMIZE: store non-zigzagged during the decode passes, | ||
2180 | // and only de-zigzag when dequantizing | ||
2181 | static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac) | ||
2182 | { | ||
2183 | int k; | ||
2184 | if (j->spec_start == 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); | ||
2185 | |||
2186 | if (j->succ_high == 0) { | ||
2187 | int shift = j->succ_low; | ||
2188 | |||
2189 | if (j->eob_run) { | ||
2190 | --j->eob_run; | ||
2191 | return 1; | ||
2192 | } | ||
2193 | |||
2194 | k = j->spec_start; | ||
2195 | do { | ||
2196 | unsigned int zig; | ||
2197 | int c,r,s; | ||
2198 | if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); | ||
2199 | c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); | ||
2200 | r = fac[c]; | ||
2201 | if (r) { // fast-AC path | ||
2202 | k += (r >> 4) & 15; // run | ||
2203 | s = r & 15; // combined length | ||
2204 | j->code_buffer <<= s; | ||
2205 | j->code_bits -= s; | ||
2206 | zig = stbi__jpeg_dezigzag[k++]; | ||
2207 | data[zig] = (short) ((r >> 8) << shift); | ||
2208 | } else { | ||
2209 | int rs = stbi__jpeg_huff_decode(j, hac); | ||
2210 | if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); | ||
2211 | s = rs & 15; | ||
2212 | r = rs >> 4; | ||
2213 | if (s == 0) { | ||
2214 | if (r < 15) { | ||
2215 | j->eob_run = (1 << r); | ||
2216 | if (r) | ||
2217 | j->eob_run += stbi__jpeg_get_bits(j, r); | ||
2218 | --j->eob_run; | ||
2219 | break; | ||
2220 | } | ||
2221 | k += 16; | ||
2222 | } else { | ||
2223 | k += r; | ||
2224 | zig = stbi__jpeg_dezigzag[k++]; | ||
2225 | data[zig] = (short) (stbi__extend_receive(j,s) << shift); | ||
2226 | } | ||
2227 | } | ||
2228 | } while (k <= j->spec_end); | ||
2229 | } else { | ||
2230 | // refinement scan for these AC coefficients | ||
2231 | |||
2232 | short bit = (short) (1 << j->succ_low); | ||
2233 | |||
2234 | if (j->eob_run) { | ||
2235 | --j->eob_run; | ||
2236 | for (k = j->spec_start; k <= j->spec_end; ++k) { | ||
2237 | short *p = &data[stbi__jpeg_dezigzag[k]]; | ||
2238 | if (*p != 0) | ||
2239 | if (stbi__jpeg_get_bit(j)) | ||
2240 | if ((*p & bit)==0) { | ||
2241 | if (*p > 0) | ||
2242 | *p += bit; | ||
2243 | else | ||
2244 | *p -= bit; | ||
2245 | } | ||
2246 | } | ||
2247 | } else { | ||
2248 | k = j->spec_start; | ||
2249 | do { | ||
2250 | int r,s; | ||
2251 | int rs = stbi__jpeg_huff_decode(j, hac); // @OPTIMIZE see if we can use the fast path here, advance-by-r is so slow, eh | ||
2252 | if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); | ||
2253 | s = rs & 15; | ||
2254 | r = rs >> 4; | ||
2255 | if (s == 0) { | ||
2256 | if (r < 15) { | ||
2257 | j->eob_run = (1 << r) - 1; | ||
2258 | if (r) | ||
2259 | j->eob_run += stbi__jpeg_get_bits(j, r); | ||
2260 | r = 64; // force end of block | ||
2261 | } else { | ||
2262 | // r=15 s=0 should write 16 0s, so we just do | ||
2263 | // a run of 15 0s and then write s (which is 0), | ||
2264 | // so we don't have to do anything special here | ||
2265 | } | ||
2266 | } else { | ||
2267 | if (s != 1) return stbi__err("bad huffman code", "Corrupt JPEG"); | ||
2268 | // sign bit | ||
2269 | if (stbi__jpeg_get_bit(j)) | ||
2270 | s = bit; | ||
2271 | else | ||
2272 | s = -bit; | ||
2273 | } | ||
2274 | |||
2275 | // advance by r | ||
2276 | while (k <= j->spec_end) { | ||
2277 | short *p = &data[stbi__jpeg_dezigzag[k++]]; | ||
2278 | if (*p != 0) { | ||
2279 | if (stbi__jpeg_get_bit(j)) | ||
2280 | if ((*p & bit)==0) { | ||
2281 | if (*p > 0) | ||
2282 | *p += bit; | ||
2283 | else | ||
2284 | *p -= bit; | ||
2285 | } | ||
2286 | } else { | ||
2287 | if (r == 0) { | ||
2288 | *p = (short) s; | ||
2289 | break; | ||
2290 | } | ||
2291 | --r; | ||
2292 | } | ||
2293 | } | ||
2294 | } while (k <= j->spec_end); | ||
2295 | } | ||
2296 | } | ||
2297 | return 1; | ||
2298 | } | ||
2299 | |||
2300 | // take a -128..127 value and stbi__clamp it and convert to 0..255 | ||
2301 | stbi_inline static stbi_uc stbi__clamp(int x) | ||
2302 | { | ||
2303 | // trick to use a single test to catch both cases | ||
2304 | if ((unsigned int) x > 255) { | ||
2305 | if (x < 0) return 0; | ||
2306 | if (x > 255) return 255; | ||
2307 | } | ||
2308 | return (stbi_uc) x; | ||
2309 | } | ||
2310 | |||
2311 | #define stbi__f2f(x) ((int) (((x) * 4096 + 0.5))) | ||
2312 | #define stbi__fsh(x) ((x) * 4096) | ||
2313 | |||
2314 | // derived from jidctint -- DCT_ISLOW | ||
2315 | #define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \ | ||
2316 | int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \ | ||
2317 | p2 = s2; \ | ||
2318 | p3 = s6; \ | ||
2319 | p1 = (p2+p3) * stbi__f2f(0.5411961f); \ | ||
2320 | t2 = p1 + p3*stbi__f2f(-1.847759065f); \ | ||
2321 | t3 = p1 + p2*stbi__f2f( 0.765366865f); \ | ||
2322 | p2 = s0; \ | ||
2323 | p3 = s4; \ | ||
2324 | t0 = stbi__fsh(p2+p3); \ | ||
2325 | t1 = stbi__fsh(p2-p3); \ | ||
2326 | x0 = t0+t3; \ | ||
2327 | x3 = t0-t3; \ | ||
2328 | x1 = t1+t2; \ | ||
2329 | x2 = t1-t2; \ | ||
2330 | t0 = s7; \ | ||
2331 | t1 = s5; \ | ||
2332 | t2 = s3; \ | ||
2333 | t3 = s1; \ | ||
2334 | p3 = t0+t2; \ | ||
2335 | p4 = t1+t3; \ | ||
2336 | p1 = t0+t3; \ | ||
2337 | p2 = t1+t2; \ | ||
2338 | p5 = (p3+p4)*stbi__f2f( 1.175875602f); \ | ||
2339 | t0 = t0*stbi__f2f( 0.298631336f); \ | ||
2340 | t1 = t1*stbi__f2f( 2.053119869f); \ | ||
2341 | t2 = t2*stbi__f2f( 3.072711026f); \ | ||
2342 | t3 = t3*stbi__f2f( 1.501321110f); \ | ||
2343 | p1 = p5 + p1*stbi__f2f(-0.899976223f); \ | ||
2344 | p2 = p5 + p2*stbi__f2f(-2.562915447f); \ | ||
2345 | p3 = p3*stbi__f2f(-1.961570560f); \ | ||
2346 | p4 = p4*stbi__f2f(-0.390180644f); \ | ||
2347 | t3 += p1+p4; \ | ||
2348 | t2 += p2+p3; \ | ||
2349 | t1 += p2+p4; \ | ||
2350 | t0 += p1+p3; | ||
2351 | |||
2352 | static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64]) | ||
2353 | { | ||
2354 | int i,val[64],*v=val; | ||
2355 | stbi_uc *o; | ||
2356 | short *d = data; | ||
2357 | |||
2358 | // columns | ||
2359 | for (i=0; i < 8; ++i,++d, ++v) { | ||
2360 | // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing | ||
2361 | if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0 | ||
2362 | && d[40]==0 && d[48]==0 && d[56]==0) { | ||
2363 | // no shortcut 0 seconds | ||
2364 | // (1|2|3|4|5|6|7)==0 0 seconds | ||
2365 | // all separate -0.047 seconds | ||
2366 | // 1 && 2|3 && 4|5 && 6|7: -0.047 seconds | ||
2367 | int dcterm = d[0]*4; | ||
2368 | v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm; | ||
2369 | } else { | ||
2370 | STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[56]) | ||
2371 | // constants scaled things up by 1<<12; let's bring them back | ||
2372 | // down, but keep 2 extra bits of precision | ||
2373 | x0 += 512; x1 += 512; x2 += 512; x3 += 512; | ||
2374 | v[ 0] = (x0+t3) >> 10; | ||
2375 | v[56] = (x0-t3) >> 10; | ||
2376 | v[ 8] = (x1+t2) >> 10; | ||
2377 | v[48] = (x1-t2) >> 10; | ||
2378 | v[16] = (x2+t1) >> 10; | ||
2379 | v[40] = (x2-t1) >> 10; | ||
2380 | v[24] = (x3+t0) >> 10; | ||
2381 | v[32] = (x3-t0) >> 10; | ||
2382 | } | ||
2383 | } | ||
2384 | |||
2385 | for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) { | ||
2386 | // no fast case since the first 1D IDCT spread components out | ||
2387 | STBI__IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7]) | ||
2388 | // constants scaled things up by 1<<12, plus we had 1<<2 from first | ||
2389 | // loop, plus horizontal and vertical each scale by sqrt(8) so together | ||
2390 | // we've got an extra 1<<3, so 1<<17 total we need to remove. | ||
2391 | // so we want to round that, which means adding 0.5 * 1<<17, | ||
2392 | // aka 65536. Also, we'll end up with -128 to 127 that we want | ||
2393 | // to encode as 0..255 by adding 128, so we'll add that before the shift | ||
2394 | x0 += 65536 + (128<<17); | ||
2395 | x1 += 65536 + (128<<17); | ||
2396 | x2 += 65536 + (128<<17); | ||
2397 | x3 += 65536 + (128<<17); | ||
2398 | // tried computing the shifts into temps, or'ing the temps to see | ||
2399 | // if any were out of range, but that was slower | ||
2400 | o[0] = stbi__clamp((x0+t3) >> 17); | ||
2401 | o[7] = stbi__clamp((x0-t3) >> 17); | ||
2402 | o[1] = stbi__clamp((x1+t2) >> 17); | ||
2403 | o[6] = stbi__clamp((x1-t2) >> 17); | ||
2404 | o[2] = stbi__clamp((x2+t1) >> 17); | ||
2405 | o[5] = stbi__clamp((x2-t1) >> 17); | ||
2406 | o[3] = stbi__clamp((x3+t0) >> 17); | ||
2407 | o[4] = stbi__clamp((x3-t0) >> 17); | ||
2408 | } | ||
2409 | } | ||
2410 | |||
2411 | #ifdef STBI_SSE2 | ||
2412 | // sse2 integer IDCT. not the fastest possible implementation but it | ||
2413 | // produces bit-identical results to the generic C version so it's | ||
2414 | // fully "transparent". | ||
2415 | static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) | ||
2416 | { | ||
2417 | // This is constructed to match our regular (generic) integer IDCT exactly. | ||
2418 | __m128i row0, row1, row2, row3, row4, row5, row6, row7; | ||
2419 | __m128i tmp; | ||
2420 | |||
2421 | // dot product constant: even elems=x, odd elems=y | ||
2422 | #define dct_const(x,y) _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y)) | ||
2423 | |||
2424 | // out(0) = c0[even]*x + c0[odd]*y (c0, x, y 16-bit, out 32-bit) | ||
2425 | // out(1) = c1[even]*x + c1[odd]*y | ||
2426 | #define dct_rot(out0,out1, x,y,c0,c1) \ | ||
2427 | __m128i c0##lo = _mm_unpacklo_epi16((x),(y)); \ | ||
2428 | __m128i c0##hi = _mm_unpackhi_epi16((x),(y)); \ | ||
2429 | __m128i out0##_l = _mm_madd_epi16(c0##lo, c0); \ | ||
2430 | __m128i out0##_h = _mm_madd_epi16(c0##hi, c0); \ | ||
2431 | __m128i out1##_l = _mm_madd_epi16(c0##lo, c1); \ | ||
2432 | __m128i out1##_h = _mm_madd_epi16(c0##hi, c1) | ||
2433 | |||
2434 | // out = in << 12 (in 16-bit, out 32-bit) | ||
2435 | #define dct_widen(out, in) \ | ||
2436 | __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \ | ||
2437 | __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4) | ||
2438 | |||
2439 | // wide add | ||
2440 | #define dct_wadd(out, a, b) \ | ||
2441 | __m128i out##_l = _mm_add_epi32(a##_l, b##_l); \ | ||
2442 | __m128i out##_h = _mm_add_epi32(a##_h, b##_h) | ||
2443 | |||
2444 | // wide sub | ||
2445 | #define dct_wsub(out, a, b) \ | ||
2446 | __m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \ | ||
2447 | __m128i out##_h = _mm_sub_epi32(a##_h, b##_h) | ||
2448 | |||
2449 | // butterfly a/b, add bias, then shift by "s" and pack | ||
2450 | #define dct_bfly32o(out0, out1, a,b,bias,s) \ | ||
2451 | { \ | ||
2452 | __m128i abiased_l = _mm_add_epi32(a##_l, bias); \ | ||
2453 | __m128i abiased_h = _mm_add_epi32(a##_h, bias); \ | ||
2454 | dct_wadd(sum, abiased, b); \ | ||
2455 | dct_wsub(dif, abiased, b); \ | ||
2456 | out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); \ | ||
2457 | out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \ | ||
2458 | } | ||
2459 | |||
2460 | // 8-bit interleave step (for transposes) | ||
2461 | #define dct_interleave8(a, b) \ | ||
2462 | tmp = a; \ | ||
2463 | a = _mm_unpacklo_epi8(a, b); \ | ||
2464 | b = _mm_unpackhi_epi8(tmp, b) | ||
2465 | |||
2466 | // 16-bit interleave step (for transposes) | ||
2467 | #define dct_interleave16(a, b) \ | ||
2468 | tmp = a; \ | ||
2469 | a = _mm_unpacklo_epi16(a, b); \ | ||
2470 | b = _mm_unpackhi_epi16(tmp, b) | ||
2471 | |||
2472 | #define dct_pass(bias,shift) \ | ||
2473 | { \ | ||
2474 | /* even part */ \ | ||
2475 | dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); \ | ||
2476 | __m128i sum04 = _mm_add_epi16(row0, row4); \ | ||
2477 | __m128i dif04 = _mm_sub_epi16(row0, row4); \ | ||
2478 | dct_widen(t0e, sum04); \ | ||
2479 | dct_widen(t1e, dif04); \ | ||
2480 | dct_wadd(x0, t0e, t3e); \ | ||
2481 | dct_wsub(x3, t0e, t3e); \ | ||
2482 | dct_wadd(x1, t1e, t2e); \ | ||
2483 | dct_wsub(x2, t1e, t2e); \ | ||
2484 | /* odd part */ \ | ||
2485 | dct_rot(y0o,y2o, row7,row3, rot2_0,rot2_1); \ | ||
2486 | dct_rot(y1o,y3o, row5,row1, rot3_0,rot3_1); \ | ||
2487 | __m128i sum17 = _mm_add_epi16(row1, row7); \ | ||
2488 | __m128i sum35 = _mm_add_epi16(row3, row5); \ | ||
2489 | dct_rot(y4o,y5o, sum17,sum35, rot1_0,rot1_1); \ | ||
2490 | dct_wadd(x4, y0o, y4o); \ | ||
2491 | dct_wadd(x5, y1o, y5o); \ | ||
2492 | dct_wadd(x6, y2o, y5o); \ | ||
2493 | dct_wadd(x7, y3o, y4o); \ | ||
2494 | dct_bfly32o(row0,row7, x0,x7,bias,shift); \ | ||
2495 | dct_bfly32o(row1,row6, x1,x6,bias,shift); \ | ||
2496 | dct_bfly32o(row2,row5, x2,x5,bias,shift); \ | ||
2497 | dct_bfly32o(row3,row4, x3,x4,bias,shift); \ | ||
2498 | } | ||
2499 | |||
2500 | __m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f)); | ||
2501 | __m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f( 0.765366865f), stbi__f2f(0.5411961f)); | ||
2502 | __m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f)); | ||
2503 | __m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f)); | ||
2504 | __m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f( 0.298631336f), stbi__f2f(-1.961570560f)); | ||
2505 | __m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f( 3.072711026f)); | ||
2506 | __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f( 2.053119869f), stbi__f2f(-0.390180644f)); | ||
2507 | __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f( 1.501321110f)); | ||
2508 | |||
2509 | // rounding biases in column/row passes, see stbi__idct_block for explanation. | ||
2510 | __m128i bias_0 = _mm_set1_epi32(512); | ||
2511 | __m128i bias_1 = _mm_set1_epi32(65536 + (128<<17)); | ||
2512 | |||
2513 | // load | ||
2514 | row0 = _mm_load_si128((const __m128i *) (data + 0*8)); | ||
2515 | row1 = _mm_load_si128((const __m128i *) (data + 1*8)); | ||
2516 | row2 = _mm_load_si128((const __m128i *) (data + 2*8)); | ||
2517 | row3 = _mm_load_si128((const __m128i *) (data + 3*8)); | ||
2518 | row4 = _mm_load_si128((const __m128i *) (data + 4*8)); | ||
2519 | row5 = _mm_load_si128((const __m128i *) (data + 5*8)); | ||
2520 | row6 = _mm_load_si128((const __m128i *) (data + 6*8)); | ||
2521 | row7 = _mm_load_si128((const __m128i *) (data + 7*8)); | ||
2522 | |||
2523 | // column pass | ||
2524 | dct_pass(bias_0, 10); | ||
2525 | |||
2526 | { | ||
2527 | // 16bit 8x8 transpose pass 1 | ||
2528 | dct_interleave16(row0, row4); | ||
2529 | dct_interleave16(row1, row5); | ||
2530 | dct_interleave16(row2, row6); | ||
2531 | dct_interleave16(row3, row7); | ||
2532 | |||
2533 | // transpose pass 2 | ||
2534 | dct_interleave16(row0, row2); | ||
2535 | dct_interleave16(row1, row3); | ||
2536 | dct_interleave16(row4, row6); | ||
2537 | dct_interleave16(row5, row7); | ||
2538 | |||
2539 | // transpose pass 3 | ||
2540 | dct_interleave16(row0, row1); | ||
2541 | dct_interleave16(row2, row3); | ||
2542 | dct_interleave16(row4, row5); | ||
2543 | dct_interleave16(row6, row7); | ||
2544 | } | ||
2545 | |||
2546 | // row pass | ||
2547 | dct_pass(bias_1, 17); | ||
2548 | |||
2549 | { | ||
2550 | // pack | ||
2551 | __m128i p0 = _mm_packus_epi16(row0, row1); // a0a1a2a3...a7b0b1b2b3...b7 | ||
2552 | __m128i p1 = _mm_packus_epi16(row2, row3); | ||
2553 | __m128i p2 = _mm_packus_epi16(row4, row5); | ||
2554 | __m128i p3 = _mm_packus_epi16(row6, row7); | ||
2555 | |||
2556 | // 8bit 8x8 transpose pass 1 | ||
2557 | dct_interleave8(p0, p2); // a0e0a1e1... | ||
2558 | dct_interleave8(p1, p3); // c0g0c1g1... | ||
2559 | |||
2560 | // transpose pass 2 | ||
2561 | dct_interleave8(p0, p1); // a0c0e0g0... | ||
2562 | dct_interleave8(p2, p3); // b0d0f0h0... | ||
2563 | |||
2564 | // transpose pass 3 | ||
2565 | dct_interleave8(p0, p2); // a0b0c0d0... | ||
2566 | dct_interleave8(p1, p3); // a4b4c4d4... | ||
2567 | |||
2568 | // store | ||
2569 | _mm_storel_epi64((__m128i *) out, p0); out += out_stride; | ||
2570 | _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride; | ||
2571 | _mm_storel_epi64((__m128i *) out, p2); out += out_stride; | ||
2572 | _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p2, 0x4e)); out += out_stride; | ||
2573 | _mm_storel_epi64((__m128i *) out, p1); out += out_stride; | ||
2574 | _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p1, 0x4e)); out += out_stride; | ||
2575 | _mm_storel_epi64((__m128i *) out, p3); out += out_stride; | ||
2576 | _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p3, 0x4e)); | ||
2577 | } | ||
2578 | |||
2579 | #undef dct_const | ||
2580 | #undef dct_rot | ||
2581 | #undef dct_widen | ||
2582 | #undef dct_wadd | ||
2583 | #undef dct_wsub | ||
2584 | #undef dct_bfly32o | ||
2585 | #undef dct_interleave8 | ||
2586 | #undef dct_interleave16 | ||
2587 | #undef dct_pass | ||
2588 | } | ||
2589 | |||
2590 | #endif // STBI_SSE2 | ||
2591 | |||
2592 | #ifdef STBI_NEON | ||
2593 | |||
2594 | // NEON integer IDCT. should produce bit-identical | ||
2595 | // results to the generic C version. | ||
2596 | static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) | ||
2597 | { | ||
2598 | int16x8_t row0, row1, row2, row3, row4, row5, row6, row7; | ||
2599 | |||
2600 | int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f)); | ||
2601 | int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f)); | ||
2602 | int16x4_t rot0_2 = vdup_n_s16(stbi__f2f( 0.765366865f)); | ||
2603 | int16x4_t rot1_0 = vdup_n_s16(stbi__f2f( 1.175875602f)); | ||
2604 | int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f)); | ||
2605 | int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f)); | ||
2606 | int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f)); | ||
2607 | int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f)); | ||
2608 | int16x4_t rot3_0 = vdup_n_s16(stbi__f2f( 0.298631336f)); | ||
2609 | int16x4_t rot3_1 = vdup_n_s16(stbi__f2f( 2.053119869f)); | ||
2610 | int16x4_t rot3_2 = vdup_n_s16(stbi__f2f( 3.072711026f)); | ||
2611 | int16x4_t rot3_3 = vdup_n_s16(stbi__f2f( 1.501321110f)); | ||
2612 | |||
2613 | #define dct_long_mul(out, inq, coeff) \ | ||
2614 | int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); \ | ||
2615 | int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff) | ||
2616 | |||
2617 | #define dct_long_mac(out, acc, inq, coeff) \ | ||
2618 | int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff); \ | ||
2619 | int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff) | ||
2620 | |||
2621 | #define dct_widen(out, inq) \ | ||
2622 | int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \ | ||
2623 | int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12) | ||
2624 | |||
2625 | // wide add | ||
2626 | #define dct_wadd(out, a, b) \ | ||
2627 | int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \ | ||
2628 | int32x4_t out##_h = vaddq_s32(a##_h, b##_h) | ||
2629 | |||
2630 | // wide sub | ||
2631 | #define dct_wsub(out, a, b) \ | ||
2632 | int32x4_t out##_l = vsubq_s32(a##_l, b##_l); \ | ||
2633 | int32x4_t out##_h = vsubq_s32(a##_h, b##_h) | ||
2634 | |||
2635 | // butterfly a/b, then shift using "shiftop" by "s" and pack | ||
2636 | #define dct_bfly32o(out0,out1, a,b,shiftop,s) \ | ||
2637 | { \ | ||
2638 | dct_wadd(sum, a, b); \ | ||
2639 | dct_wsub(dif, a, b); \ | ||
2640 | out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s)); \ | ||
2641 | out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s)); \ | ||
2642 | } | ||
2643 | |||
2644 | #define dct_pass(shiftop, shift) \ | ||
2645 | { \ | ||
2646 | /* even part */ \ | ||
2647 | int16x8_t sum26 = vaddq_s16(row2, row6); \ | ||
2648 | dct_long_mul(p1e, sum26, rot0_0); \ | ||
2649 | dct_long_mac(t2e, p1e, row6, rot0_1); \ | ||
2650 | dct_long_mac(t3e, p1e, row2, rot0_2); \ | ||
2651 | int16x8_t sum04 = vaddq_s16(row0, row4); \ | ||
2652 | int16x8_t dif04 = vsubq_s16(row0, row4); \ | ||
2653 | dct_widen(t0e, sum04); \ | ||
2654 | dct_widen(t1e, dif04); \ | ||
2655 | dct_wadd(x0, t0e, t3e); \ | ||
2656 | dct_wsub(x3, t0e, t3e); \ | ||
2657 | dct_wadd(x1, t1e, t2e); \ | ||
2658 | dct_wsub(x2, t1e, t2e); \ | ||
2659 | /* odd part */ \ | ||
2660 | int16x8_t sum15 = vaddq_s16(row1, row5); \ | ||
2661 | int16x8_t sum17 = vaddq_s16(row1, row7); \ | ||
2662 | int16x8_t sum35 = vaddq_s16(row3, row5); \ | ||
2663 | int16x8_t sum37 = vaddq_s16(row3, row7); \ | ||
2664 | int16x8_t sumodd = vaddq_s16(sum17, sum35); \ | ||
2665 | dct_long_mul(p5o, sumodd, rot1_0); \ | ||
2666 | dct_long_mac(p1o, p5o, sum17, rot1_1); \ | ||
2667 | dct_long_mac(p2o, p5o, sum35, rot1_2); \ | ||
2668 | dct_long_mul(p3o, sum37, rot2_0); \ | ||
2669 | dct_long_mul(p4o, sum15, rot2_1); \ | ||
2670 | dct_wadd(sump13o, p1o, p3o); \ | ||
2671 | dct_wadd(sump24o, p2o, p4o); \ | ||
2672 | dct_wadd(sump23o, p2o, p3o); \ | ||
2673 | dct_wadd(sump14o, p1o, p4o); \ | ||
2674 | dct_long_mac(x4, sump13o, row7, rot3_0); \ | ||
2675 | dct_long_mac(x5, sump24o, row5, rot3_1); \ | ||
2676 | dct_long_mac(x6, sump23o, row3, rot3_2); \ | ||
2677 | dct_long_mac(x7, sump14o, row1, rot3_3); \ | ||
2678 | dct_bfly32o(row0,row7, x0,x7,shiftop,shift); \ | ||
2679 | dct_bfly32o(row1,row6, x1,x6,shiftop,shift); \ | ||
2680 | dct_bfly32o(row2,row5, x2,x5,shiftop,shift); \ | ||
2681 | dct_bfly32o(row3,row4, x3,x4,shiftop,shift); \ | ||
2682 | } | ||
2683 | |||
2684 | // load | ||
2685 | row0 = vld1q_s16(data + 0*8); | ||
2686 | row1 = vld1q_s16(data + 1*8); | ||
2687 | row2 = vld1q_s16(data + 2*8); | ||
2688 | row3 = vld1q_s16(data + 3*8); | ||
2689 | row4 = vld1q_s16(data + 4*8); | ||
2690 | row5 = vld1q_s16(data + 5*8); | ||
2691 | row6 = vld1q_s16(data + 6*8); | ||
2692 | row7 = vld1q_s16(data + 7*8); | ||
2693 | |||
2694 | // add DC bias | ||
2695 | row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0)); | ||
2696 | |||
2697 | // column pass | ||
2698 | dct_pass(vrshrn_n_s32, 10); | ||
2699 | |||
2700 | // 16bit 8x8 transpose | ||
2701 | { | ||
2702 | // these three map to a single VTRN.16, VTRN.32, and VSWP, respectively. | ||
2703 | // whether compilers actually get this is another story, sadly. | ||
2704 | #define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; } | ||
2705 | #define dct_trn32(x, y) { int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); x = vreinterpretq_s16_s32(t.val[0]); y = vreinterpretq_s16_s32(t.val[1]); } | ||
2706 | #define dct_trn64(x, y) { int16x8_t x0 = x; int16x8_t y0 = y; x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); } | ||
2707 | |||
2708 | // pass 1 | ||
2709 | dct_trn16(row0, row1); // a0b0a2b2a4b4a6b6 | ||
2710 | dct_trn16(row2, row3); | ||
2711 | dct_trn16(row4, row5); | ||
2712 | dct_trn16(row6, row7); | ||
2713 | |||
2714 | // pass 2 | ||
2715 | dct_trn32(row0, row2); // a0b0c0d0a4b4c4d4 | ||
2716 | dct_trn32(row1, row3); | ||
2717 | dct_trn32(row4, row6); | ||
2718 | dct_trn32(row5, row7); | ||
2719 | |||
2720 | // pass 3 | ||
2721 | dct_trn64(row0, row4); // a0b0c0d0e0f0g0h0 | ||
2722 | dct_trn64(row1, row5); | ||
2723 | dct_trn64(row2, row6); | ||
2724 | dct_trn64(row3, row7); | ||
2725 | |||
2726 | #undef dct_trn16 | ||
2727 | #undef dct_trn32 | ||
2728 | #undef dct_trn64 | ||
2729 | } | ||
2730 | |||
2731 | // row pass | ||
2732 | // vrshrn_n_s32 only supports shifts up to 16, we need | ||
2733 | // 17. so do a non-rounding shift of 16 first then follow | ||
2734 | // up with a rounding shift by 1. | ||
2735 | dct_pass(vshrn_n_s32, 16); | ||
2736 | |||
2737 | { | ||
2738 | // pack and round | ||
2739 | uint8x8_t p0 = vqrshrun_n_s16(row0, 1); | ||
2740 | uint8x8_t p1 = vqrshrun_n_s16(row1, 1); | ||
2741 | uint8x8_t p2 = vqrshrun_n_s16(row2, 1); | ||
2742 | uint8x8_t p3 = vqrshrun_n_s16(row3, 1); | ||
2743 | uint8x8_t p4 = vqrshrun_n_s16(row4, 1); | ||
2744 | uint8x8_t p5 = vqrshrun_n_s16(row5, 1); | ||
2745 | uint8x8_t p6 = vqrshrun_n_s16(row6, 1); | ||
2746 | uint8x8_t p7 = vqrshrun_n_s16(row7, 1); | ||
2747 | |||
2748 | // again, these can translate into one instruction, but often don't. | ||
2749 | #define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; } | ||
2750 | #define dct_trn8_16(x, y) { uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); x = vreinterpret_u8_u16(t.val[0]); y = vreinterpret_u8_u16(t.val[1]); } | ||
2751 | #define dct_trn8_32(x, y) { uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); x = vreinterpret_u8_u32(t.val[0]); y = vreinterpret_u8_u32(t.val[1]); } | ||
2752 | |||
2753 | // sadly can't use interleaved stores here since we only write | ||
2754 | // 8 bytes to each scan line! | ||
2755 | |||
2756 | // 8x8 8-bit transpose pass 1 | ||
2757 | dct_trn8_8(p0, p1); | ||
2758 | dct_trn8_8(p2, p3); | ||
2759 | dct_trn8_8(p4, p5); | ||
2760 | dct_trn8_8(p6, p7); | ||
2761 | |||
2762 | // pass 2 | ||
2763 | dct_trn8_16(p0, p2); | ||
2764 | dct_trn8_16(p1, p3); | ||
2765 | dct_trn8_16(p4, p6); | ||
2766 | dct_trn8_16(p5, p7); | ||
2767 | |||
2768 | // pass 3 | ||
2769 | dct_trn8_32(p0, p4); | ||
2770 | dct_trn8_32(p1, p5); | ||
2771 | dct_trn8_32(p2, p6); | ||
2772 | dct_trn8_32(p3, p7); | ||
2773 | |||
2774 | // store | ||
2775 | vst1_u8(out, p0); out += out_stride; | ||
2776 | vst1_u8(out, p1); out += out_stride; | ||
2777 | vst1_u8(out, p2); out += out_stride; | ||
2778 | vst1_u8(out, p3); out += out_stride; | ||
2779 | vst1_u8(out, p4); out += out_stride; | ||
2780 | vst1_u8(out, p5); out += out_stride; | ||
2781 | vst1_u8(out, p6); out += out_stride; | ||
2782 | vst1_u8(out, p7); | ||
2783 | |||
2784 | #undef dct_trn8_8 | ||
2785 | #undef dct_trn8_16 | ||
2786 | #undef dct_trn8_32 | ||
2787 | } | ||
2788 | |||
2789 | #undef dct_long_mul | ||
2790 | #undef dct_long_mac | ||
2791 | #undef dct_widen | ||
2792 | #undef dct_wadd | ||
2793 | #undef dct_wsub | ||
2794 | #undef dct_bfly32o | ||
2795 | #undef dct_pass | ||
2796 | } | ||
2797 | |||
2798 | #endif // STBI_NEON | ||
2799 | |||
2800 | #define STBI__MARKER_none 0xff | ||
2801 | // if there's a pending marker from the entropy stream, return that | ||
2802 | // otherwise, fetch from the stream and get a marker. if there's no | ||
2803 | // marker, return 0xff, which is never a valid marker value | ||
2804 | static stbi_uc stbi__get_marker(stbi__jpeg *j) | ||
2805 | { | ||
2806 | stbi_uc x; | ||
2807 | if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; } | ||
2808 | x = stbi__get8(j->s); | ||
2809 | if (x != 0xff) return STBI__MARKER_none; | ||
2810 | while (x == 0xff) | ||
2811 | x = stbi__get8(j->s); // consume repeated 0xff fill bytes | ||
2812 | return x; | ||
2813 | } | ||
2814 | |||
2815 | // in each scan, we'll have scan_n components, and the order | ||
2816 | // of the components is specified by order[] | ||
2817 | #define STBI__RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7) | ||
2818 | |||
2819 | // after a restart interval, stbi__jpeg_reset the entropy decoder and | ||
2820 | // the dc prediction | ||
2821 | static void stbi__jpeg_reset(stbi__jpeg *j) | ||
2822 | { | ||
2823 | j->code_bits = 0; | ||
2824 | j->code_buffer = 0; | ||
2825 | j->nomore = 0; | ||
2826 | j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = j->img_comp[3].dc_pred = 0; | ||
2827 | j->marker = STBI__MARKER_none; | ||
2828 | j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff; | ||
2829 | j->eob_run = 0; | ||
2830 | // no more than 1<<31 MCUs if no restart_interal? that's plenty safe, | ||
2831 | // since we don't even allow 1<<30 pixels | ||
2832 | } | ||
2833 | |||
2834 | static int stbi__parse_entropy_coded_data(stbi__jpeg *z) | ||
2835 | { | ||
2836 | stbi__jpeg_reset(z); | ||
2837 | if (!z->progressive) { | ||
2838 | if (z->scan_n == 1) { | ||
2839 | int i,j; | ||
2840 | STBI_SIMD_ALIGN(short, data[64]); | ||
2841 | int n = z->order[0]; | ||
2842 | // non-interleaved data, we just need to process one block at a time, | ||
2843 | // in trivial scanline order | ||
2844 | // number of blocks to do just depends on how many actual "pixels" this | ||
2845 | // component has, independent of interleaved MCU blocking and such | ||
2846 | int w = (z->img_comp[n].x+7) >> 3; | ||
2847 | int h = (z->img_comp[n].y+7) >> 3; | ||
2848 | for (j=0; j < h; ++j) { | ||
2849 | for (i=0; i < w; ++i) { | ||
2850 | int ha = z->img_comp[n].ha; | ||
2851 | if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; | ||
2852 | z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); | ||
2853 | // every data block is an MCU, so countdown the restart interval | ||
2854 | if (--z->todo <= 0) { | ||
2855 | if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); | ||
2856 | // if it's NOT a restart, then just bail, so we get corrupt data | ||
2857 | // rather than no data | ||
2858 | if (!STBI__RESTART(z->marker)) return 1; | ||
2859 | stbi__jpeg_reset(z); | ||
2860 | } | ||
2861 | } | ||
2862 | } | ||
2863 | return 1; | ||
2864 | } else { // interleaved | ||
2865 | int i,j,k,x,y; | ||
2866 | STBI_SIMD_ALIGN(short, data[64]); | ||
2867 | for (j=0; j < z->img_mcu_y; ++j) { | ||
2868 | for (i=0; i < z->img_mcu_x; ++i) { | ||
2869 | // scan an interleaved mcu... process scan_n components in order | ||
2870 | for (k=0; k < z->scan_n; ++k) { | ||
2871 | int n = z->order[k]; | ||
2872 | // scan out an mcu's worth of this component; that's just determined | ||
2873 | // by the basic H and V specified for the component | ||
2874 | for (y=0; y < z->img_comp[n].v; ++y) { | ||
2875 | for (x=0; x < z->img_comp[n].h; ++x) { | ||
2876 | int x2 = (i*z->img_comp[n].h + x)*8; | ||
2877 | int y2 = (j*z->img_comp[n].v + y)*8; | ||
2878 | int ha = z->img_comp[n].ha; | ||
2879 | if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; | ||
2880 | z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data); | ||
2881 | } | ||
2882 | } | ||
2883 | } | ||
2884 | // after all interleaved components, that's an interleaved MCU, | ||
2885 | // so now count down the restart interval | ||
2886 | if (--z->todo <= 0) { | ||
2887 | if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); | ||
2888 | if (!STBI__RESTART(z->marker)) return 1; | ||
2889 | stbi__jpeg_reset(z); | ||
2890 | } | ||
2891 | } | ||
2892 | } | ||
2893 | return 1; | ||
2894 | } | ||
2895 | } else { | ||
2896 | if (z->scan_n == 1) { | ||
2897 | int i,j; | ||
2898 | int n = z->order[0]; | ||
2899 | // non-interleaved data, we just need to process one block at a time, | ||
2900 | // in trivial scanline order | ||
2901 | // number of blocks to do just depends on how many actual "pixels" this | ||
2902 | // component has, independent of interleaved MCU blocking and such | ||
2903 | int w = (z->img_comp[n].x+7) >> 3; | ||
2904 | int h = (z->img_comp[n].y+7) >> 3; | ||
2905 | for (j=0; j < h; ++j) { | ||
2906 | for (i=0; i < w; ++i) { | ||
2907 | short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); | ||
2908 | if (z->spec_start == 0) { | ||
2909 | if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) | ||
2910 | return 0; | ||
2911 | } else { | ||
2912 | int ha = z->img_comp[n].ha; | ||
2913 | if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha])) | ||
2914 | return 0; | ||
2915 | } | ||
2916 | // every data block is an MCU, so countdown the restart interval | ||
2917 | if (--z->todo <= 0) { | ||
2918 | if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); | ||
2919 | if (!STBI__RESTART(z->marker)) return 1; | ||
2920 | stbi__jpeg_reset(z); | ||
2921 | } | ||
2922 | } | ||
2923 | } | ||
2924 | return 1; | ||
2925 | } else { // interleaved | ||
2926 | int i,j,k,x,y; | ||
2927 | for (j=0; j < z->img_mcu_y; ++j) { | ||
2928 | for (i=0; i < z->img_mcu_x; ++i) { | ||
2929 | // scan an interleaved mcu... process scan_n components in order | ||
2930 | for (k=0; k < z->scan_n; ++k) { | ||
2931 | int n = z->order[k]; | ||
2932 | // scan out an mcu's worth of this component; that's just determined | ||
2933 | // by the basic H and V specified for the component | ||
2934 | for (y=0; y < z->img_comp[n].v; ++y) { | ||
2935 | for (x=0; x < z->img_comp[n].h; ++x) { | ||
2936 | int x2 = (i*z->img_comp[n].h + x); | ||
2937 | int y2 = (j*z->img_comp[n].v + y); | ||
2938 | short *data = z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w); | ||
2939 | if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) | ||
2940 | return 0; | ||
2941 | } | ||
2942 | } | ||
2943 | } | ||
2944 | // after all interleaved components, that's an interleaved MCU, | ||
2945 | // so now count down the restart interval | ||
2946 | if (--z->todo <= 0) { | ||
2947 | if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); | ||
2948 | if (!STBI__RESTART(z->marker)) return 1; | ||
2949 | stbi__jpeg_reset(z); | ||
2950 | } | ||
2951 | } | ||
2952 | } | ||
2953 | return 1; | ||
2954 | } | ||
2955 | } | ||
2956 | } | ||
2957 | |||
2958 | static void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant) | ||
2959 | { | ||
2960 | int i; | ||
2961 | for (i=0; i < 64; ++i) | ||
2962 | data[i] *= dequant[i]; | ||
2963 | } | ||
2964 | |||
2965 | static void stbi__jpeg_finish(stbi__jpeg *z) | ||
2966 | { | ||
2967 | if (z->progressive) { | ||
2968 | // dequantize and idct the data | ||
2969 | int i,j,n; | ||
2970 | for (n=0; n < z->s->img_n; ++n) { | ||
2971 | int w = (z->img_comp[n].x+7) >> 3; | ||
2972 | int h = (z->img_comp[n].y+7) >> 3; | ||
2973 | for (j=0; j < h; ++j) { | ||
2974 | for (i=0; i < w; ++i) { | ||
2975 | short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); | ||
2976 | stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]); | ||
2977 | z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); | ||
2978 | } | ||
2979 | } | ||
2980 | } | ||
2981 | } | ||
2982 | } | ||
2983 | |||
2984 | static int stbi__process_marker(stbi__jpeg *z, int m) | ||
2985 | { | ||
2986 | int L; | ||
2987 | switch (m) { | ||
2988 | case STBI__MARKER_none: // no marker found | ||
2989 | return stbi__err("expected marker","Corrupt JPEG"); | ||
2990 | |||
2991 | case 0xDD: // DRI - specify restart interval | ||
2992 | if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len","Corrupt JPEG"); | ||
2993 | z->restart_interval = stbi__get16be(z->s); | ||
2994 | return 1; | ||
2995 | |||
2996 | case 0xDB: // DQT - define quantization table | ||
2997 | L = stbi__get16be(z->s)-2; | ||
2998 | while (L > 0) { | ||
2999 | int q = stbi__get8(z->s); | ||
3000 | int p = q >> 4, sixteen = (p != 0); | ||
3001 | int t = q & 15,i; | ||
3002 | if (p != 0 && p != 1) return stbi__err("bad DQT type","Corrupt JPEG"); | ||
3003 | if (t > 3) return stbi__err("bad DQT table","Corrupt JPEG"); | ||
3004 | |||
3005 | for (i=0; i < 64; ++i) | ||
3006 | z->dequant[t][stbi__jpeg_dezigzag[i]] = (stbi__uint16)(sixteen ? stbi__get16be(z->s) : stbi__get8(z->s)); | ||
3007 | L -= (sixteen ? 129 : 65); | ||
3008 | } | ||
3009 | return L==0; | ||
3010 | |||
3011 | case 0xC4: // DHT - define huffman table | ||
3012 | L = stbi__get16be(z->s)-2; | ||
3013 | while (L > 0) { | ||
3014 | stbi_uc *v; | ||
3015 | int sizes[16],i,n=0; | ||
3016 | int q = stbi__get8(z->s); | ||
3017 | int tc = q >> 4; | ||
3018 | int th = q & 15; | ||
3019 | if (tc > 1 || th > 3) return stbi__err("bad DHT header","Corrupt JPEG"); | ||
3020 | for (i=0; i < 16; ++i) { | ||
3021 | sizes[i] = stbi__get8(z->s); | ||
3022 | n += sizes[i]; | ||
3023 | } | ||
3024 | L -= 17; | ||
3025 | if (tc == 0) { | ||
3026 | if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0; | ||
3027 | v = z->huff_dc[th].values; | ||
3028 | } else { | ||
3029 | if (!stbi__build_huffman(z->huff_ac+th, sizes)) return 0; | ||
3030 | v = z->huff_ac[th].values; | ||
3031 | } | ||
3032 | for (i=0; i < n; ++i) | ||
3033 | v[i] = stbi__get8(z->s); | ||
3034 | if (tc != 0) | ||
3035 | stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th); | ||
3036 | L -= n; | ||
3037 | } | ||
3038 | return L==0; | ||
3039 | } | ||
3040 | |||
3041 | // check for comment block or APP blocks | ||
3042 | if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) { | ||
3043 | L = stbi__get16be(z->s); | ||
3044 | if (L < 2) { | ||
3045 | if (m == 0xFE) | ||
3046 | return stbi__err("bad COM len","Corrupt JPEG"); | ||
3047 | else | ||
3048 | return stbi__err("bad APP len","Corrupt JPEG"); | ||
3049 | } | ||
3050 | L -= 2; | ||
3051 | |||
3052 | if (m == 0xE0 && L >= 5) { // JFIF APP0 segment | ||
3053 | static const unsigned char tag[5] = {'J','F','I','F','\0'}; | ||
3054 | int ok = 1; | ||
3055 | int i; | ||
3056 | for (i=0; i < 5; ++i) | ||
3057 | if (stbi__get8(z->s) != tag[i]) | ||
3058 | ok = 0; | ||
3059 | L -= 5; | ||
3060 | if (ok) | ||
3061 | z->jfif = 1; | ||
3062 | } else if (m == 0xEE && L >= 12) { // Adobe APP14 segment | ||
3063 | static const unsigned char tag[6] = {'A','d','o','b','e','\0'}; | ||
3064 | int ok = 1; | ||
3065 | int i; | ||
3066 | for (i=0; i < 6; ++i) | ||
3067 | if (stbi__get8(z->s) != tag[i]) | ||
3068 | ok = 0; | ||
3069 | L -= 6; | ||
3070 | if (ok) { | ||
3071 | stbi__get8(z->s); // version | ||
3072 | stbi__get16be(z->s); // flags0 | ||
3073 | stbi__get16be(z->s); // flags1 | ||
3074 | z->app14_color_transform = stbi__get8(z->s); // color transform | ||
3075 | L -= 6; | ||
3076 | } | ||
3077 | } | ||
3078 | |||
3079 | stbi__skip(z->s, L); | ||
3080 | return 1; | ||
3081 | } | ||
3082 | |||
3083 | return stbi__err("unknown marker","Corrupt JPEG"); | ||
3084 | } | ||
3085 | |||
3086 | // after we see SOS | ||
3087 | static int stbi__process_scan_header(stbi__jpeg *z) | ||
3088 | { | ||
3089 | int i; | ||
3090 | int Ls = stbi__get16be(z->s); | ||
3091 | z->scan_n = stbi__get8(z->s); | ||
3092 | if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s->img_n) return stbi__err("bad SOS component count","Corrupt JPEG"); | ||
3093 | if (Ls != 6+2*z->scan_n) return stbi__err("bad SOS len","Corrupt JPEG"); | ||
3094 | for (i=0; i < z->scan_n; ++i) { | ||
3095 | int id = stbi__get8(z->s), which; | ||
3096 | int q = stbi__get8(z->s); | ||
3097 | for (which = 0; which < z->s->img_n; ++which) | ||
3098 | if (z->img_comp[which].id == id) | ||
3099 | break; | ||
3100 | if (which == z->s->img_n) return 0; // no match | ||
3101 | z->img_comp[which].hd = q >> 4; if (z->img_comp[which].hd > 3) return stbi__err("bad DC huff","Corrupt JPEG"); | ||
3102 | z->img_comp[which].ha = q & 15; if (z->img_comp[which].ha > 3) return stbi__err("bad AC huff","Corrupt JPEG"); | ||
3103 | z->order[i] = which; | ||
3104 | } | ||
3105 | |||
3106 | { | ||
3107 | int aa; | ||
3108 | z->spec_start = stbi__get8(z->s); | ||
3109 | z->spec_end = stbi__get8(z->s); // should be 63, but might be 0 | ||
3110 | aa = stbi__get8(z->s); | ||
3111 | z->succ_high = (aa >> 4); | ||
3112 | z->succ_low = (aa & 15); | ||
3113 | if (z->progressive) { | ||
3114 | if (z->spec_start > 63 || z->spec_end > 63 || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13) | ||
3115 | return stbi__err("bad SOS", "Corrupt JPEG"); | ||
3116 | } else { | ||
3117 | if (z->spec_start != 0) return stbi__err("bad SOS","Corrupt JPEG"); | ||
3118 | if (z->succ_high != 0 || z->succ_low != 0) return stbi__err("bad SOS","Corrupt JPEG"); | ||
3119 | z->spec_end = 63; | ||
3120 | } | ||
3121 | } | ||
3122 | |||
3123 | return 1; | ||
3124 | } | ||
3125 | |||
3126 | static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why) | ||
3127 | { | ||
3128 | int i; | ||
3129 | for (i=0; i < ncomp; ++i) { | ||
3130 | if (z->img_comp[i].raw_data) { | ||
3131 | STBI_FREE(z->img_comp[i].raw_data); | ||
3132 | z->img_comp[i].raw_data = NULL; | ||
3133 | z->img_comp[i].data = NULL; | ||
3134 | } | ||
3135 | if (z->img_comp[i].raw_coeff) { | ||
3136 | STBI_FREE(z->img_comp[i].raw_coeff); | ||
3137 | z->img_comp[i].raw_coeff = 0; | ||
3138 | z->img_comp[i].coeff = 0; | ||
3139 | } | ||
3140 | if (z->img_comp[i].linebuf) { | ||
3141 | STBI_FREE(z->img_comp[i].linebuf); | ||
3142 | z->img_comp[i].linebuf = NULL; | ||
3143 | } | ||
3144 | } | ||
3145 | return why; | ||
3146 | } | ||
3147 | |||
3148 | static int stbi__process_frame_header(stbi__jpeg *z, int scan) | ||
3149 | { | ||
3150 | stbi__context *s = z->s; | ||
3151 | int Lf,p,i,q, h_max=1,v_max=1,c; | ||
3152 | Lf = stbi__get16be(s); if (Lf < 11) return stbi__err("bad SOF len","Corrupt JPEG"); // JPEG | ||
3153 | p = stbi__get8(s); if (p != 8) return stbi__err("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline | ||
3154 | s->img_y = stbi__get16be(s); if (s->img_y == 0) return stbi__err("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG | ||
3155 | s->img_x = stbi__get16be(s); if (s->img_x == 0) return stbi__err("0 width","Corrupt JPEG"); // JPEG requires | ||
3156 | c = stbi__get8(s); | ||
3157 | if (c != 3 && c != 1 && c != 4) return stbi__err("bad component count","Corrupt JPEG"); | ||
3158 | s->img_n = c; | ||
3159 | for (i=0; i < c; ++i) { | ||
3160 | z->img_comp[i].data = NULL; | ||
3161 | z->img_comp[i].linebuf = NULL; | ||
3162 | } | ||
3163 | |||
3164 | if (Lf != 8+3*s->img_n) return stbi__err("bad SOF len","Corrupt JPEG"); | ||
3165 | |||
3166 | z->rgb = 0; | ||
3167 | for (i=0; i < s->img_n; ++i) { | ||
3168 | static const unsigned char rgb[3] = { 'R', 'G', 'B' }; | ||
3169 | z->img_comp[i].id = stbi__get8(s); | ||
3170 | if (s->img_n == 3 && z->img_comp[i].id == rgb[i]) | ||
3171 | ++z->rgb; | ||
3172 | q = stbi__get8(s); | ||
3173 | z->img_comp[i].h = (q >> 4); if (!z->img_comp[i].h || z->img_comp[i].h > 4) return stbi__err("bad H","Corrupt JPEG"); | ||
3174 | z->img_comp[i].v = q & 15; if (!z->img_comp[i].v || z->img_comp[i].v > 4) return stbi__err("bad V","Corrupt JPEG"); | ||
3175 | z->img_comp[i].tq = stbi__get8(s); if (z->img_comp[i].tq > 3) return stbi__err("bad TQ","Corrupt JPEG"); | ||
3176 | } | ||
3177 | |||
3178 | if (scan != STBI__SCAN_load) return 1; | ||
3179 | |||
3180 | if (!stbi__mad3sizes_valid(s->img_x, s->img_y, s->img_n, 0)) return stbi__err("too large", "Image too large to decode"); | ||
3181 | |||
3182 | for (i=0; i < s->img_n; ++i) { | ||
3183 | if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h; | ||
3184 | if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v; | ||
3185 | } | ||
3186 | |||
3187 | // compute interleaved mcu info | ||
3188 | z->img_h_max = h_max; | ||
3189 | z->img_v_max = v_max; | ||
3190 | z->img_mcu_w = h_max * 8; | ||
3191 | z->img_mcu_h = v_max * 8; | ||
3192 | // these sizes can't be more than 17 bits | ||
3193 | z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w; | ||
3194 | z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h; | ||
3195 | |||
3196 | for (i=0; i < s->img_n; ++i) { | ||
3197 | // number of effective pixels (e.g. for non-interleaved MCU) | ||
3198 | z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max; | ||
3199 | z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max; | ||
3200 | // to simplify generation, we'll allocate enough memory to decode | ||
3201 | // the bogus oversized data from using interleaved MCUs and their | ||
3202 | // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't | ||
3203 | // discard the extra data until colorspace conversion | ||
3204 | // | ||
3205 | // img_mcu_x, img_mcu_y: <=17 bits; comp[i].h and .v are <=4 (checked earlier) | ||
3206 | // so these muls can't overflow with 32-bit ints (which we require) | ||
3207 | z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8; | ||
3208 | z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8; | ||
3209 | z->img_comp[i].coeff = 0; | ||
3210 | z->img_comp[i].raw_coeff = 0; | ||
3211 | z->img_comp[i].linebuf = NULL; | ||
3212 | z->img_comp[i].raw_data = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15); | ||
3213 | if (z->img_comp[i].raw_data == NULL) | ||
3214 | return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory")); | ||
3215 | // align blocks for idct using mmx/sse | ||
3216 | z->img_comp[i].data = (stbi_uc*) (((size_t) z->img_comp[i].raw_data + 15) & ~15); | ||
3217 | if (z->progressive) { | ||
3218 | // w2, h2 are multiples of 8 (see above) | ||
3219 | z->img_comp[i].coeff_w = z->img_comp[i].w2 / 8; | ||
3220 | z->img_comp[i].coeff_h = z->img_comp[i].h2 / 8; | ||
3221 | z->img_comp[i].raw_coeff = stbi__malloc_mad3(z->img_comp[i].w2, z->img_comp[i].h2, sizeof(short), 15); | ||
3222 | if (z->img_comp[i].raw_coeff == NULL) | ||
3223 | return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory")); | ||
3224 | z->img_comp[i].coeff = (short*) (((size_t) z->img_comp[i].raw_coeff + 15) & ~15); | ||
3225 | } | ||
3226 | } | ||
3227 | |||
3228 | return 1; | ||
3229 | } | ||
3230 | |||
3231 | // use comparisons since in some cases we handle more than one case (e.g. SOF) | ||
3232 | #define stbi__DNL(x) ((x) == 0xdc) | ||
3233 | #define stbi__SOI(x) ((x) == 0xd8) | ||
3234 | #define stbi__EOI(x) ((x) == 0xd9) | ||
3235 | #define stbi__SOF(x) ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2) | ||
3236 | #define stbi__SOS(x) ((x) == 0xda) | ||
3237 | |||
3238 | #define stbi__SOF_progressive(x) ((x) == 0xc2) | ||
3239 | |||
3240 | static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan) | ||
3241 | { | ||
3242 | int m; | ||
3243 | z->jfif = 0; | ||
3244 | z->app14_color_transform = -1; // valid values are 0,1,2 | ||
3245 | z->marker = STBI__MARKER_none; // initialize cached marker to empty | ||
3246 | m = stbi__get_marker(z); | ||
3247 | if (!stbi__SOI(m)) return stbi__err("no SOI","Corrupt JPEG"); | ||
3248 | if (scan == STBI__SCAN_type) return 1; | ||
3249 | m = stbi__get_marker(z); | ||
3250 | while (!stbi__SOF(m)) { | ||
3251 | if (!stbi__process_marker(z,m)) return 0; | ||
3252 | m = stbi__get_marker(z); | ||
3253 | while (m == STBI__MARKER_none) { | ||
3254 | // some files have extra padding after their blocks, so ok, we'll scan | ||
3255 | if (stbi__at_eof(z->s)) return stbi__err("no SOF", "Corrupt JPEG"); | ||
3256 | m = stbi__get_marker(z); | ||
3257 | } | ||
3258 | } | ||
3259 | z->progressive = stbi__SOF_progressive(m); | ||
3260 | if (!stbi__process_frame_header(z, scan)) return 0; | ||
3261 | return 1; | ||
3262 | } | ||
3263 | |||
3264 | // decode image to YCbCr format | ||
3265 | static int stbi__decode_jpeg_image(stbi__jpeg *j) | ||
3266 | { | ||
3267 | int m; | ||
3268 | for (m = 0; m < 4; m++) { | ||
3269 | j->img_comp[m].raw_data = NULL; | ||
3270 | j->img_comp[m].raw_coeff = NULL; | ||
3271 | } | ||
3272 | j->restart_interval = 0; | ||
3273 | if (!stbi__decode_jpeg_header(j, STBI__SCAN_load)) return 0; | ||
3274 | m = stbi__get_marker(j); | ||
3275 | while (!stbi__EOI(m)) { | ||
3276 | if (stbi__SOS(m)) { | ||
3277 | if (!stbi__process_scan_header(j)) return 0; | ||
3278 | if (!stbi__parse_entropy_coded_data(j)) return 0; | ||
3279 | if (j->marker == STBI__MARKER_none ) { | ||
3280 | // handle 0s at the end of image data from IP Kamera 9060 | ||
3281 | while (!stbi__at_eof(j->s)) { | ||
3282 | int x = stbi__get8(j->s); | ||
3283 | if (x == 255) { | ||
3284 | j->marker = stbi__get8(j->s); | ||
3285 | break; | ||
3286 | } | ||
3287 | } | ||
3288 | // if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0 | ||
3289 | } | ||
3290 | } else if (stbi__DNL(m)) { | ||
3291 | int Ld = stbi__get16be(j->s); | ||
3292 | stbi__uint32 NL = stbi__get16be(j->s); | ||
3293 | if (Ld != 4) return stbi__err("bad DNL len", "Corrupt JPEG"); | ||
3294 | if (NL != j->s->img_y) return stbi__err("bad DNL height", "Corrupt JPEG"); | ||
3295 | } else { | ||
3296 | if (!stbi__process_marker(j, m)) return 0; | ||
3297 | } | ||
3298 | m = stbi__get_marker(j); | ||
3299 | } | ||
3300 | if (j->progressive) | ||
3301 | stbi__jpeg_finish(j); | ||
3302 | return 1; | ||
3303 | } | ||
3304 | |||
3305 | // static jfif-centered resampling (across block boundaries) | ||
3306 | |||
3307 | typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1, | ||
3308 | int w, int hs); | ||
3309 | |||
3310 | #define stbi__div4(x) ((stbi_uc) ((x) >> 2)) | ||
3311 | |||
3312 | static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) | ||
3313 | { | ||
3314 | STBI_NOTUSED(out); | ||
3315 | STBI_NOTUSED(in_far); | ||
3316 | STBI_NOTUSED(w); | ||
3317 | STBI_NOTUSED(hs); | ||
3318 | return in_near; | ||
3319 | } | ||
3320 | |||
3321 | static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) | ||
3322 | { | ||
3323 | // need to generate two samples vertically for every one in input | ||
3324 | int i; | ||
3325 | STBI_NOTUSED(hs); | ||
3326 | for (i=0; i < w; ++i) | ||
3327 | out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2); | ||
3328 | return out; | ||
3329 | } | ||
3330 | |||
3331 | static stbi_uc* stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) | ||
3332 | { | ||
3333 | // need to generate two samples horizontally for every one in input | ||
3334 | int i; | ||
3335 | stbi_uc *input = in_near; | ||
3336 | |||
3337 | if (w == 1) { | ||
3338 | // if only one sample, can't do any interpolation | ||
3339 | out[0] = out[1] = input[0]; | ||
3340 | return out; | ||
3341 | } | ||
3342 | |||
3343 | out[0] = input[0]; | ||
3344 | out[1] = stbi__div4(input[0]*3 + input[1] + 2); | ||
3345 | for (i=1; i < w-1; ++i) { | ||
3346 | int n = 3*input[i]+2; | ||
3347 | out[i*2+0] = stbi__div4(n+input[i-1]); | ||
3348 | out[i*2+1] = stbi__div4(n+input[i+1]); | ||
3349 | } | ||
3350 | out[i*2+0] = stbi__div4(input[w-2]*3 + input[w-1] + 2); | ||
3351 | out[i*2+1] = input[w-1]; | ||
3352 | |||
3353 | STBI_NOTUSED(in_far); | ||
3354 | STBI_NOTUSED(hs); | ||
3355 | |||
3356 | return out; | ||
3357 | } | ||
3358 | |||
3359 | #define stbi__div16(x) ((stbi_uc) ((x) >> 4)) | ||
3360 | |||
3361 | static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) | ||
3362 | { | ||
3363 | // need to generate 2x2 samples for every one in input | ||
3364 | int i,t0,t1; | ||
3365 | if (w == 1) { | ||
3366 | out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); | ||
3367 | return out; | ||
3368 | } | ||
3369 | |||
3370 | t1 = 3*in_near[0] + in_far[0]; | ||
3371 | out[0] = stbi__div4(t1+2); | ||
3372 | for (i=1; i < w; ++i) { | ||
3373 | t0 = t1; | ||
3374 | t1 = 3*in_near[i]+in_far[i]; | ||
3375 | out[i*2-1] = stbi__div16(3*t0 + t1 + 8); | ||
3376 | out[i*2 ] = stbi__div16(3*t1 + t0 + 8); | ||
3377 | } | ||
3378 | out[w*2-1] = stbi__div4(t1+2); | ||
3379 | |||
3380 | STBI_NOTUSED(hs); | ||
3381 | |||
3382 | return out; | ||
3383 | } | ||
3384 | |||
3385 | #if defined(STBI_SSE2) || defined(STBI_NEON) | ||
3386 | static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) | ||
3387 | { | ||
3388 | // need to generate 2x2 samples for every one in input | ||
3389 | int i=0,t0,t1; | ||
3390 | |||
3391 | if (w == 1) { | ||
3392 | out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); | ||
3393 | return out; | ||
3394 | } | ||
3395 | |||
3396 | t1 = 3*in_near[0] + in_far[0]; | ||
3397 | // process groups of 8 pixels for as long as we can. | ||
3398 | // note we can't handle the last pixel in a row in this loop | ||
3399 | // because we need to handle the filter boundary conditions. | ||
3400 | for (; i < ((w-1) & ~7); i += 8) { | ||
3401 | #if defined(STBI_SSE2) | ||
3402 | // load and perform the vertical filtering pass | ||
3403 | // this uses 3*x + y = 4*x + (y - x) | ||
3404 | __m128i zero = _mm_setzero_si128(); | ||
3405 | __m128i farb = _mm_loadl_epi64((__m128i *) (in_far + i)); | ||
3406 | __m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i)); | ||
3407 | __m128i farw = _mm_unpacklo_epi8(farb, zero); | ||
3408 | __m128i nearw = _mm_unpacklo_epi8(nearb, zero); | ||
3409 | __m128i diff = _mm_sub_epi16(farw, nearw); | ||
3410 | __m128i nears = _mm_slli_epi16(nearw, 2); | ||
3411 | __m128i curr = _mm_add_epi16(nears, diff); // current row | ||
3412 | |||
3413 | // horizontal filter works the same based on shifted vers of current | ||
3414 | // row. "prev" is current row shifted right by 1 pixel; we need to | ||
3415 | // insert the previous pixel value (from t1). | ||
3416 | // "next" is current row shifted left by 1 pixel, with first pixel | ||
3417 | // of next block of 8 pixels added in. | ||
3418 | __m128i prv0 = _mm_slli_si128(curr, 2); | ||
3419 | __m128i nxt0 = _mm_srli_si128(curr, 2); | ||
3420 | __m128i prev = _mm_insert_epi16(prv0, t1, 0); | ||
3421 | __m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7); | ||
3422 | |||
3423 | // horizontal filter, polyphase implementation since it's convenient: | ||
3424 | // even pixels = 3*cur + prev = cur*4 + (prev - cur) | ||
3425 | // odd pixels = 3*cur + next = cur*4 + (next - cur) | ||
3426 | // note the shared term. | ||
3427 | __m128i bias = _mm_set1_epi16(8); | ||
3428 | __m128i curs = _mm_slli_epi16(curr, 2); | ||
3429 | __m128i prvd = _mm_sub_epi16(prev, curr); | ||
3430 | __m128i nxtd = _mm_sub_epi16(next, curr); | ||
3431 | __m128i curb = _mm_add_epi16(curs, bias); | ||
3432 | __m128i even = _mm_add_epi16(prvd, curb); | ||
3433 | __m128i odd = _mm_add_epi16(nxtd, curb); | ||
3434 | |||
3435 | // interleave even and odd pixels, then undo scaling. | ||
3436 | __m128i int0 = _mm_unpacklo_epi16(even, odd); | ||
3437 | __m128i int1 = _mm_unpackhi_epi16(even, odd); | ||
3438 | __m128i de0 = _mm_srli_epi16(int0, 4); | ||
3439 | __m128i de1 = _mm_srli_epi16(int1, 4); | ||
3440 | |||
3441 | // pack and write output | ||
3442 | __m128i outv = _mm_packus_epi16(de0, de1); | ||
3443 | _mm_storeu_si128((__m128i *) (out + i*2), outv); | ||
3444 | #elif defined(STBI_NEON) | ||
3445 | // load and perform the vertical filtering pass | ||
3446 | // this uses 3*x + y = 4*x + (y - x) | ||
3447 | uint8x8_t farb = vld1_u8(in_far + i); | ||
3448 | uint8x8_t nearb = vld1_u8(in_near + i); | ||
3449 | int16x8_t diff = vreinterpretq_s16_u16(vsubl_u8(farb, nearb)); | ||
3450 | int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2)); | ||
3451 | int16x8_t curr = vaddq_s16(nears, diff); // current row | ||
3452 | |||
3453 | // horizontal filter works the same based on shifted vers of current | ||
3454 | // row. "prev" is current row shifted right by 1 pixel; we need to | ||
3455 | // insert the previous pixel value (from t1). | ||
3456 | // "next" is current row shifted left by 1 pixel, with first pixel | ||
3457 | // of next block of 8 pixels added in. | ||
3458 | int16x8_t prv0 = vextq_s16(curr, curr, 7); | ||
3459 | int16x8_t nxt0 = vextq_s16(curr, curr, 1); | ||
3460 | int16x8_t prev = vsetq_lane_s16(t1, prv0, 0); | ||
3461 | int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7); | ||
3462 | |||
3463 | // horizontal filter, polyphase implementation since it's convenient: | ||
3464 | // even pixels = 3*cur + prev = cur*4 + (prev - cur) | ||
3465 | // odd pixels = 3*cur + next = cur*4 + (next - cur) | ||
3466 | // note the shared term. | ||
3467 | int16x8_t curs = vshlq_n_s16(curr, 2); | ||
3468 | int16x8_t prvd = vsubq_s16(prev, curr); | ||
3469 | int16x8_t nxtd = vsubq_s16(next, curr); | ||
3470 | int16x8_t even = vaddq_s16(curs, prvd); | ||
3471 | int16x8_t odd = vaddq_s16(curs, nxtd); | ||
3472 | |||
3473 | // undo scaling and round, then store with even/odd phases interleaved | ||
3474 | uint8x8x2_t o; | ||
3475 | o.val[0] = vqrshrun_n_s16(even, 4); | ||
3476 | o.val[1] = vqrshrun_n_s16(odd, 4); | ||
3477 | vst2_u8(out + i*2, o); | ||
3478 | #endif | ||
3479 | |||
3480 | // "previous" value for next iter | ||
3481 | t1 = 3*in_near[i+7] + in_far[i+7]; | ||
3482 | } | ||
3483 | |||
3484 | t0 = t1; | ||
3485 | t1 = 3*in_near[i] + in_far[i]; | ||
3486 | out[i*2] = stbi__div16(3*t1 + t0 + 8); | ||
3487 | |||
3488 | for (++i; i < w; ++i) { | ||
3489 | t0 = t1; | ||
3490 | t1 = 3*in_near[i]+in_far[i]; | ||
3491 | out[i*2-1] = stbi__div16(3*t0 + t1 + 8); | ||
3492 | out[i*2 ] = stbi__div16(3*t1 + t0 + 8); | ||
3493 | } | ||
3494 | out[w*2-1] = stbi__div4(t1+2); | ||
3495 | |||
3496 | STBI_NOTUSED(hs); | ||
3497 | |||
3498 | return out; | ||
3499 | } | ||
3500 | #endif | ||
3501 | |||
3502 | static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) | ||
3503 | { | ||
3504 | // resample with nearest-neighbor | ||
3505 | int i,j; | ||
3506 | STBI_NOTUSED(in_far); | ||
3507 | for (i=0; i < w; ++i) | ||
3508 | for (j=0; j < hs; ++j) | ||
3509 | out[i*hs+j] = in_near[i]; | ||
3510 | return out; | ||
3511 | } | ||
3512 | |||
3513 | // this is a reduced-precision calculation of YCbCr-to-RGB introduced | ||
3514 | // to make sure the code produces the same results in both SIMD and scalar | ||
3515 | #define stbi__float2fixed(x) (((int) ((x) * 4096.0f + 0.5f)) << 8) | ||
3516 | static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step) | ||
3517 | { | ||
3518 | int i; | ||
3519 | for (i=0; i < count; ++i) { | ||
3520 | int y_fixed = (y[i] << 20) + (1<<19); // rounding | ||
3521 | int r,g,b; | ||
3522 | int cr = pcr[i] - 128; | ||
3523 | int cb = pcb[i] - 128; | ||
3524 | r = y_fixed + cr* stbi__float2fixed(1.40200f); | ||
3525 | g = y_fixed + (cr*-stbi__float2fixed(0.71414f)) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000); | ||
3526 | b = y_fixed + cb* stbi__float2fixed(1.77200f); | ||
3527 | r >>= 20; | ||
3528 | g >>= 20; | ||
3529 | b >>= 20; | ||
3530 | if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } | ||
3531 | if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } | ||
3532 | if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } | ||
3533 | out[0] = (stbi_uc)r; | ||
3534 | out[1] = (stbi_uc)g; | ||
3535 | out[2] = (stbi_uc)b; | ||
3536 | out[3] = 255; | ||
3537 | out += step; | ||
3538 | } | ||
3539 | } | ||
3540 | |||
3541 | #if defined(STBI_SSE2) || defined(STBI_NEON) | ||
3542 | static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc const *pcr, int count, int step) | ||
3543 | { | ||
3544 | int i = 0; | ||
3545 | |||
3546 | #ifdef STBI_SSE2 | ||
3547 | // step == 3 is pretty ugly on the final interleave, and i'm not convinced | ||
3548 | // it's useful in practice (you wouldn't use it for textures, for example). | ||
3549 | // so just accelerate step == 4 case. | ||
3550 | if (step == 4) { | ||
3551 | // this is a fairly straightforward implementation and not super-optimized. | ||
3552 | __m128i signflip = _mm_set1_epi8(-0x80); | ||
3553 | __m128i cr_const0 = _mm_set1_epi16( (short) ( 1.40200f*4096.0f+0.5f)); | ||
3554 | __m128i cr_const1 = _mm_set1_epi16( - (short) ( 0.71414f*4096.0f+0.5f)); | ||
3555 | __m128i cb_const0 = _mm_set1_epi16( - (short) ( 0.34414f*4096.0f+0.5f)); | ||
3556 | __m128i cb_const1 = _mm_set1_epi16( (short) ( 1.77200f*4096.0f+0.5f)); | ||
3557 | __m128i y_bias = _mm_set1_epi8((char) (unsigned char) 128); | ||
3558 | __m128i xw = _mm_set1_epi16(255); // alpha channel | ||
3559 | |||
3560 | for (; i+7 < count; i += 8) { | ||
3561 | // load | ||
3562 | __m128i y_bytes = _mm_loadl_epi64((__m128i *) (y+i)); | ||
3563 | __m128i cr_bytes = _mm_loadl_epi64((__m128i *) (pcr+i)); | ||
3564 | __m128i cb_bytes = _mm_loadl_epi64((__m128i *) (pcb+i)); | ||
3565 | __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip); // -128 | ||
3566 | __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip); // -128 | ||
3567 | |||
3568 | // unpack to short (and left-shift cr, cb by 8) | ||
3569 | __m128i yw = _mm_unpacklo_epi8(y_bias, y_bytes); | ||
3570 | __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased); | ||
3571 | __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased); | ||
3572 | |||
3573 | // color transform | ||
3574 | __m128i yws = _mm_srli_epi16(yw, 4); | ||
3575 | __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw); | ||
3576 | __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw); | ||
3577 | __m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1); | ||
3578 | __m128i cr1 = _mm_mulhi_epi16(crw, cr_const1); | ||
3579 | __m128i rws = _mm_add_epi16(cr0, yws); | ||
3580 | __m128i gwt = _mm_add_epi16(cb0, yws); | ||
3581 | __m128i bws = _mm_add_epi16(yws, cb1); | ||
3582 | __m128i gws = _mm_add_epi16(gwt, cr1); | ||
3583 | |||
3584 | // descale | ||
3585 | __m128i rw = _mm_srai_epi16(rws, 4); | ||
3586 | __m128i bw = _mm_srai_epi16(bws, 4); | ||
3587 | __m128i gw = _mm_srai_epi16(gws, 4); | ||
3588 | |||
3589 | // back to byte, set up for transpose | ||
3590 | __m128i brb = _mm_packus_epi16(rw, bw); | ||
3591 | __m128i gxb = _mm_packus_epi16(gw, xw); | ||
3592 | |||
3593 | // transpose to interleave channels | ||
3594 | __m128i t0 = _mm_unpacklo_epi8(brb, gxb); | ||
3595 | __m128i t1 = _mm_unpackhi_epi8(brb, gxb); | ||
3596 | __m128i o0 = _mm_unpacklo_epi16(t0, t1); | ||
3597 | __m128i o1 = _mm_unpackhi_epi16(t0, t1); | ||
3598 | |||
3599 | // store | ||
3600 | _mm_storeu_si128((__m128i *) (out + 0), o0); | ||
3601 | _mm_storeu_si128((__m128i *) (out + 16), o1); | ||
3602 | out += 32; | ||
3603 | } | ||
3604 | } | ||
3605 | #endif | ||
3606 | |||
3607 | #ifdef STBI_NEON | ||
3608 | // in this version, step=3 support would be easy to add. but is there demand? | ||
3609 | if (step == 4) { | ||
3610 | // this is a fairly straightforward implementation and not super-optimized. | ||
3611 | uint8x8_t signflip = vdup_n_u8(0x80); | ||
3612 | int16x8_t cr_const0 = vdupq_n_s16( (short) ( 1.40200f*4096.0f+0.5f)); | ||
3613 | int16x8_t cr_const1 = vdupq_n_s16( - (short) ( 0.71414f*4096.0f+0.5f)); | ||
3614 | int16x8_t cb_const0 = vdupq_n_s16( - (short) ( 0.34414f*4096.0f+0.5f)); | ||
3615 | int16x8_t cb_const1 = vdupq_n_s16( (short) ( 1.77200f*4096.0f+0.5f)); | ||
3616 | |||
3617 | for (; i+7 < count; i += 8) { | ||
3618 | // load | ||
3619 | uint8x8_t y_bytes = vld1_u8(y + i); | ||
3620 | uint8x8_t cr_bytes = vld1_u8(pcr + i); | ||
3621 | uint8x8_t cb_bytes = vld1_u8(pcb + i); | ||
3622 | int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip)); | ||
3623 | int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip)); | ||
3624 | |||
3625 | // expand to s16 | ||
3626 | int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4)); | ||
3627 | int16x8_t crw = vshll_n_s8(cr_biased, 7); | ||
3628 | int16x8_t cbw = vshll_n_s8(cb_biased, 7); | ||
3629 | |||
3630 | // color transform | ||
3631 | int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0); | ||
3632 | int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0); | ||
3633 | int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1); | ||
3634 | int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1); | ||
3635 | int16x8_t rws = vaddq_s16(yws, cr0); | ||
3636 | int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1); | ||
3637 | int16x8_t bws = vaddq_s16(yws, cb1); | ||
3638 | |||
3639 | // undo scaling, round, convert to byte | ||
3640 | uint8x8x4_t o; | ||
3641 | o.val[0] = vqrshrun_n_s16(rws, 4); | ||
3642 | o.val[1] = vqrshrun_n_s16(gws, 4); | ||
3643 | o.val[2] = vqrshrun_n_s16(bws, 4); | ||
3644 | o.val[3] = vdup_n_u8(255); | ||
3645 | |||
3646 | // store, interleaving r/g/b/a | ||
3647 | vst4_u8(out, o); | ||
3648 | out += 8*4; | ||
3649 | } | ||
3650 | } | ||
3651 | #endif | ||
3652 | |||
3653 | for (; i < count; ++i) { | ||
3654 | int y_fixed = (y[i] << 20) + (1<<19); // rounding | ||
3655 | int r,g,b; | ||
3656 | int cr = pcr[i] - 128; | ||
3657 | int cb = pcb[i] - 128; | ||
3658 | r = y_fixed + cr* stbi__float2fixed(1.40200f); | ||
3659 | g = y_fixed + cr*-stbi__float2fixed(0.71414f) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000); | ||
3660 | b = y_fixed + cb* stbi__float2fixed(1.77200f); | ||
3661 | r >>= 20; | ||
3662 | g >>= 20; | ||
3663 | b >>= 20; | ||
3664 | if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } | ||
3665 | if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } | ||
3666 | if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } | ||
3667 | out[0] = (stbi_uc)r; | ||
3668 | out[1] = (stbi_uc)g; | ||
3669 | out[2] = (stbi_uc)b; | ||
3670 | out[3] = 255; | ||
3671 | out += step; | ||
3672 | } | ||
3673 | } | ||
3674 | #endif | ||
3675 | |||
3676 | // set up the kernels | ||
3677 | static void stbi__setup_jpeg(stbi__jpeg *j) | ||
3678 | { | ||
3679 | j->idct_block_kernel = stbi__idct_block; | ||
3680 | j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row; | ||
3681 | j->resample_row_hv_2_kernel = stbi__resample_row_hv_2; | ||
3682 | |||
3683 | #ifdef STBI_SSE2 | ||
3684 | if (stbi__sse2_available()) { | ||
3685 | j->idct_block_kernel = stbi__idct_simd; | ||
3686 | j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; | ||
3687 | j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; | ||
3688 | } | ||
3689 | #endif | ||
3690 | |||
3691 | #ifdef STBI_NEON | ||
3692 | j->idct_block_kernel = stbi__idct_simd; | ||
3693 | j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; | ||
3694 | j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; | ||
3695 | #endif | ||
3696 | } | ||
3697 | |||
3698 | // clean up the temporary component buffers | ||
3699 | static void stbi__cleanup_jpeg(stbi__jpeg *j) | ||
3700 | { | ||
3701 | stbi__free_jpeg_components(j, j->s->img_n, 0); | ||
3702 | } | ||
3703 | |||
3704 | typedef struct | ||
3705 | { | ||
3706 | resample_row_func resample; | ||
3707 | stbi_uc *line0,*line1; | ||
3708 | int hs,vs; // expansion factor in each axis | ||
3709 | int w_lores; // horizontal pixels pre-expansion | ||
3710 | int ystep; // how far through vertical expansion we are | ||
3711 | int ypos; // which pre-expansion row we're on | ||
3712 | } stbi__resample; | ||
3713 | |||
3714 | // fast 0..255 * 0..255 => 0..255 rounded multiplication | ||
3715 | static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y) | ||
3716 | { | ||
3717 | unsigned int t = x*y + 128; | ||
3718 | return (stbi_uc) ((t + (t >>8)) >> 8); | ||
3719 | } | ||
3720 | |||
3721 | static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp) | ||
3722 | { | ||
3723 | int n, decode_n, is_rgb; | ||
3724 | z->s->img_n = 0; // make stbi__cleanup_jpeg safe | ||
3725 | |||
3726 | // validate req_comp | ||
3727 | if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); | ||
3728 | |||
3729 | // load a jpeg image from whichever source, but leave in YCbCr format | ||
3730 | if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; } | ||
3731 | |||
3732 | // determine actual number of components to generate | ||
3733 | n = req_comp ? req_comp : z->s->img_n >= 3 ? 3 : 1; | ||
3734 | |||
3735 | is_rgb = z->s->img_n == 3 && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif)); | ||
3736 | |||
3737 | if (z->s->img_n == 3 && n < 3 && !is_rgb) | ||
3738 | decode_n = 1; | ||
3739 | else | ||
3740 | decode_n = z->s->img_n; | ||
3741 | |||
3742 | // resample and color-convert | ||
3743 | { | ||
3744 | int k; | ||
3745 | unsigned int i,j; | ||
3746 | stbi_uc *output; | ||
3747 | stbi_uc *coutput[4] = { NULL, NULL, NULL, NULL }; | ||
3748 | |||
3749 | stbi__resample res_comp[4]; | ||
3750 | |||
3751 | for (k=0; k < decode_n; ++k) { | ||
3752 | stbi__resample *r = &res_comp[k]; | ||
3753 | |||
3754 | // allocate line buffer big enough for upsampling off the edges | ||
3755 | // with upsample factor of 4 | ||
3756 | z->img_comp[k].linebuf = (stbi_uc *) stbi__malloc(z->s->img_x + 3); | ||
3757 | if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } | ||
3758 | |||
3759 | r->hs = z->img_h_max / z->img_comp[k].h; | ||
3760 | r->vs = z->img_v_max / z->img_comp[k].v; | ||
3761 | r->ystep = r->vs >> 1; | ||
3762 | r->w_lores = (z->s->img_x + r->hs-1) / r->hs; | ||
3763 | r->ypos = 0; | ||
3764 | r->line0 = r->line1 = z->img_comp[k].data; | ||
3765 | |||
3766 | if (r->hs == 1 && r->vs == 1) r->resample = resample_row_1; | ||
3767 | else if (r->hs == 1 && r->vs == 2) r->resample = stbi__resample_row_v_2; | ||
3768 | else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2; | ||
3769 | else if (r->hs == 2 && r->vs == 2) r->resample = z->resample_row_hv_2_kernel; | ||
3770 | else r->resample = stbi__resample_row_generic; | ||
3771 | } | ||
3772 | |||
3773 | // can't error after this so, this is safe | ||
3774 | output = (stbi_uc *) stbi__malloc_mad3(n, z->s->img_x, z->s->img_y, 1); | ||
3775 | if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } | ||
3776 | |||
3777 | // now go ahead and resample | ||
3778 | for (j=0; j < z->s->img_y; ++j) { | ||
3779 | stbi_uc *out = output + n * z->s->img_x * j; | ||
3780 | for (k=0; k < decode_n; ++k) { | ||
3781 | stbi__resample *r = &res_comp[k]; | ||
3782 | int y_bot = r->ystep >= (r->vs >> 1); | ||
3783 | coutput[k] = r->resample(z->img_comp[k].linebuf, | ||
3784 | y_bot ? r->line1 : r->line0, | ||
3785 | y_bot ? r->line0 : r->line1, | ||
3786 | r->w_lores, r->hs); | ||
3787 | if (++r->ystep >= r->vs) { | ||
3788 | r->ystep = 0; | ||
3789 | r->line0 = r->line1; | ||
3790 | if (++r->ypos < z->img_comp[k].y) | ||
3791 | r->line1 += z->img_comp[k].w2; | ||
3792 | } | ||
3793 | } | ||
3794 | if (n >= 3) { | ||
3795 | stbi_uc *y = coutput[0]; | ||
3796 | if (z->s->img_n == 3) { | ||
3797 | if (is_rgb) { | ||
3798 | for (i=0; i < z->s->img_x; ++i) { | ||
3799 | out[0] = y[i]; | ||
3800 | out[1] = coutput[1][i]; | ||
3801 | out[2] = coutput[2][i]; | ||
3802 | out[3] = 255; | ||
3803 | out += n; | ||
3804 | } | ||
3805 | } else { | ||
3806 | z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); | ||
3807 | } | ||
3808 | } else if (z->s->img_n == 4) { | ||
3809 | if (z->app14_color_transform == 0) { // CMYK | ||
3810 | for (i=0; i < z->s->img_x; ++i) { | ||
3811 | stbi_uc m = coutput[3][i]; | ||
3812 | out[0] = stbi__blinn_8x8(coutput[0][i], m); | ||
3813 | out[1] = stbi__blinn_8x8(coutput[1][i], m); | ||
3814 | out[2] = stbi__blinn_8x8(coutput[2][i], m); | ||
3815 | out[3] = 255; | ||
3816 | out += n; | ||
3817 | } | ||
3818 | } else if (z->app14_color_transform == 2) { // YCCK | ||
3819 | z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); | ||
3820 | for (i=0; i < z->s->img_x; ++i) { | ||
3821 | stbi_uc m = coutput[3][i]; | ||
3822 | out[0] = stbi__blinn_8x8(255 - out[0], m); | ||
3823 | out[1] = stbi__blinn_8x8(255 - out[1], m); | ||
3824 | out[2] = stbi__blinn_8x8(255 - out[2], m); | ||
3825 | out += n; | ||
3826 | } | ||
3827 | } else { // YCbCr + alpha? Ignore the fourth channel for now | ||
3828 | z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); | ||
3829 | } | ||
3830 | } else | ||
3831 | for (i=0; i < z->s->img_x; ++i) { | ||
3832 | out[0] = out[1] = out[2] = y[i]; | ||
3833 | out[3] = 255; // not used if n==3 | ||
3834 | out += n; | ||
3835 | } | ||
3836 | } else { | ||
3837 | if (is_rgb) { | ||
3838 | if (n == 1) | ||
3839 | for (i=0; i < z->s->img_x; ++i) | ||
3840 | *out++ = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); | ||
3841 | else { | ||
3842 | for (i=0; i < z->s->img_x; ++i, out += 2) { | ||
3843 | out[0] = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); | ||
3844 | out[1] = 255; | ||
3845 | } | ||
3846 | } | ||
3847 | } else if (z->s->img_n == 4 && z->app14_color_transform == 0) { | ||
3848 | for (i=0; i < z->s->img_x; ++i) { | ||
3849 | stbi_uc m = coutput[3][i]; | ||
3850 | stbi_uc r = stbi__blinn_8x8(coutput[0][i], m); | ||
3851 | stbi_uc g = stbi__blinn_8x8(coutput[1][i], m); | ||
3852 | stbi_uc b = stbi__blinn_8x8(coutput[2][i], m); | ||
3853 | out[0] = stbi__compute_y(r, g, b); | ||
3854 | out[1] = 255; | ||
3855 | out += n; | ||
3856 | } | ||
3857 | } else if (z->s->img_n == 4 && z->app14_color_transform == 2) { | ||
3858 | for (i=0; i < z->s->img_x; ++i) { | ||
3859 | out[0] = stbi__blinn_8x8(255 - coutput[0][i], coutput[3][i]); | ||
3860 | out[1] = 255; | ||
3861 | out += n; | ||
3862 | } | ||
3863 | } else { | ||
3864 | stbi_uc *y = coutput[0]; | ||
3865 | if (n == 1) | ||
3866 | for (i=0; i < z->s->img_x; ++i) out[i] = y[i]; | ||
3867 | else | ||
3868 | for (i=0; i < z->s->img_x; ++i) { *out++ = y[i]; *out++ = 255; } | ||
3869 | } | ||
3870 | } | ||
3871 | } | ||
3872 | stbi__cleanup_jpeg(z); | ||
3873 | *out_x = z->s->img_x; | ||
3874 | *out_y = z->s->img_y; | ||
3875 | if (comp) *comp = z->s->img_n >= 3 ? 3 : 1; // report original components, not output | ||
3876 | return output; | ||
3877 | } | ||
3878 | } | ||
3879 | |||
3880 | static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) | ||
3881 | { | ||
3882 | unsigned char* result; | ||
3883 | stbi__jpeg* j = (stbi__jpeg*) stbi__malloc(sizeof(stbi__jpeg)); | ||
3884 | STBI_NOTUSED(ri); | ||
3885 | j->s = s; | ||
3886 | stbi__setup_jpeg(j); | ||
3887 | result = load_jpeg_image(j, x,y,comp,req_comp); | ||
3888 | STBI_FREE(j); | ||
3889 | return result; | ||
3890 | } | ||
3891 | |||
3892 | static int stbi__jpeg_test(stbi__context *s) | ||
3893 | { | ||
3894 | int r; | ||
3895 | stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(sizeof(stbi__jpeg)); | ||
3896 | j->s = s; | ||
3897 | stbi__setup_jpeg(j); | ||
3898 | r = stbi__decode_jpeg_header(j, STBI__SCAN_type); | ||
3899 | stbi__rewind(s); | ||
3900 | STBI_FREE(j); | ||
3901 | return r; | ||
3902 | } | ||
3903 | |||
3904 | static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp) | ||
3905 | { | ||
3906 | if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) { | ||
3907 | stbi__rewind( j->s ); | ||
3908 | return 0; | ||
3909 | } | ||
3910 | if (x) *x = j->s->img_x; | ||
3911 | if (y) *y = j->s->img_y; | ||
3912 | if (comp) *comp = j->s->img_n >= 3 ? 3 : 1; | ||
3913 | return 1; | ||
3914 | } | ||
3915 | |||
3916 | static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp) | ||
3917 | { | ||
3918 | int result; | ||
3919 | stbi__jpeg* j = (stbi__jpeg*) (stbi__malloc(sizeof(stbi__jpeg))); | ||
3920 | j->s = s; | ||
3921 | result = stbi__jpeg_info_raw(j, x, y, comp); | ||
3922 | STBI_FREE(j); | ||
3923 | return result; | ||
3924 | } | ||
3925 | #endif | ||
3926 | |||
3927 | // public domain zlib decode v0.2 Sean Barrett 2006-11-18 | ||
3928 | // simple implementation | ||
3929 | // - all input must be provided in an upfront buffer | ||
3930 | // - all output is written to a single output buffer (can malloc/realloc) | ||
3931 | // performance | ||
3932 | // - fast huffman | ||
3933 | |||
3934 | #ifndef STBI_NO_ZLIB | ||
3935 | |||
3936 | // fast-way is faster to check than jpeg huffman, but slow way is slower | ||
3937 | #define STBI__ZFAST_BITS 9 // accelerate all cases in default tables | ||
3938 | #define STBI__ZFAST_MASK ((1 << STBI__ZFAST_BITS) - 1) | ||
3939 | |||
3940 | // zlib-style huffman encoding | ||
3941 | // (jpegs packs from left, zlib from right, so can't share code) | ||
3942 | typedef struct | ||
3943 | { | ||
3944 | stbi__uint16 fast[1 << STBI__ZFAST_BITS]; | ||
3945 | stbi__uint16 firstcode[16]; | ||
3946 | int maxcode[17]; | ||
3947 | stbi__uint16 firstsymbol[16]; | ||
3948 | stbi_uc size[288]; | ||
3949 | stbi__uint16 value[288]; | ||
3950 | } stbi__zhuffman; | ||
3951 | |||
3952 | stbi_inline static int stbi__bitreverse16(int n) | ||
3953 | { | ||
3954 | n = ((n & 0xAAAA) >> 1) | ((n & 0x5555) << 1); | ||
3955 | n = ((n & 0xCCCC) >> 2) | ((n & 0x3333) << 2); | ||
3956 | n = ((n & 0xF0F0) >> 4) | ((n & 0x0F0F) << 4); | ||
3957 | n = ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8); | ||
3958 | return n; | ||
3959 | } | ||
3960 | |||
3961 | stbi_inline static int stbi__bit_reverse(int v, int bits) | ||
3962 | { | ||
3963 | STBI_ASSERT(bits <= 16); | ||
3964 | // to bit reverse n bits, reverse 16 and shift | ||
3965 | // e.g. 11 bits, bit reverse and shift away 5 | ||
3966 | return stbi__bitreverse16(v) >> (16-bits); | ||
3967 | } | ||
3968 | |||
3969 | static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num) | ||
3970 | { | ||
3971 | int i,k=0; | ||
3972 | int code, next_code[16], sizes[17]; | ||
3973 | |||
3974 | // DEFLATE spec for generating codes | ||
3975 | memset(sizes, 0, sizeof(sizes)); | ||
3976 | memset(z->fast, 0, sizeof(z->fast)); | ||
3977 | for (i=0; i < num; ++i) | ||
3978 | ++sizes[sizelist[i]]; | ||
3979 | sizes[0] = 0; | ||
3980 | for (i=1; i < 16; ++i) | ||
3981 | if (sizes[i] > (1 << i)) | ||
3982 | return stbi__err("bad sizes", "Corrupt PNG"); | ||
3983 | code = 0; | ||
3984 | for (i=1; i < 16; ++i) { | ||
3985 | next_code[i] = code; | ||
3986 | z->firstcode[i] = (stbi__uint16) code; | ||
3987 | z->firstsymbol[i] = (stbi__uint16) k; | ||
3988 | code = (code + sizes[i]); | ||
3989 | if (sizes[i]) | ||
3990 | if (code-1 >= (1 << i)) return stbi__err("bad codelengths","Corrupt PNG"); | ||
3991 | z->maxcode[i] = code << (16-i); // preshift for inner loop | ||
3992 | code <<= 1; | ||
3993 | k += sizes[i]; | ||
3994 | } | ||
3995 | z->maxcode[16] = 0x10000; // sentinel | ||
3996 | for (i=0; i < num; ++i) { | ||
3997 | int s = sizelist[i]; | ||
3998 | if (s) { | ||
3999 | int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s]; | ||
4000 | stbi__uint16 fastv = (stbi__uint16) ((s << 9) | i); | ||
4001 | z->size [c] = (stbi_uc ) s; | ||
4002 | z->value[c] = (stbi__uint16) i; | ||
4003 | if (s <= STBI__ZFAST_BITS) { | ||
4004 | int j = stbi__bit_reverse(next_code[s],s); | ||
4005 | while (j < (1 << STBI__ZFAST_BITS)) { | ||
4006 | z->fast[j] = fastv; | ||
4007 | j += (1 << s); | ||
4008 | } | ||
4009 | } | ||
4010 | ++next_code[s]; | ||
4011 | } | ||
4012 | } | ||
4013 | return 1; | ||
4014 | } | ||
4015 | |||
4016 | // zlib-from-memory implementation for PNG reading | ||
4017 | // because PNG allows splitting the zlib stream arbitrarily, | ||
4018 | // and it's annoying structurally to have PNG call ZLIB call PNG, | ||
4019 | // we require PNG read all the IDATs and combine them into a single | ||
4020 | // memory buffer | ||
4021 | |||
4022 | typedef struct | ||
4023 | { | ||
4024 | stbi_uc *zbuffer, *zbuffer_end; | ||
4025 | int num_bits; | ||
4026 | stbi__uint32 code_buffer; | ||
4027 | |||
4028 | char *zout; | ||
4029 | char *zout_start; | ||
4030 | char *zout_end; | ||
4031 | int z_expandable; | ||
4032 | |||
4033 | stbi__zhuffman z_length, z_distance; | ||
4034 | } stbi__zbuf; | ||
4035 | |||
4036 | stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z) | ||
4037 | { | ||
4038 | if (z->zbuffer >= z->zbuffer_end) return 0; | ||
4039 | return *z->zbuffer++; | ||
4040 | } | ||
4041 | |||
4042 | static void stbi__fill_bits(stbi__zbuf *z) | ||
4043 | { | ||
4044 | do { | ||
4045 | STBI_ASSERT(z->code_buffer < (1U << z->num_bits)); | ||
4046 | z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits; | ||
4047 | z->num_bits += 8; | ||
4048 | } while (z->num_bits <= 24); | ||
4049 | } | ||
4050 | |||
4051 | stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n) | ||
4052 | { | ||
4053 | unsigned int k; | ||
4054 | if (z->num_bits < n) stbi__fill_bits(z); | ||
4055 | k = z->code_buffer & ((1 << n) - 1); | ||
4056 | z->code_buffer >>= n; | ||
4057 | z->num_bits -= n; | ||
4058 | return k; | ||
4059 | } | ||
4060 | |||
4061 | static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z) | ||
4062 | { | ||
4063 | int b,s,k; | ||
4064 | // not resolved by fast table, so compute it the slow way | ||
4065 | // use jpeg approach, which requires MSbits at top | ||
4066 | k = stbi__bit_reverse(a->code_buffer, 16); | ||
4067 | for (s=STBI__ZFAST_BITS+1; ; ++s) | ||
4068 | if (k < z->maxcode[s]) | ||
4069 | break; | ||
4070 | if (s == 16) return -1; // invalid code! | ||
4071 | // code size is s, so: | ||
4072 | b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s]; | ||
4073 | STBI_ASSERT(z->size[b] == s); | ||
4074 | a->code_buffer >>= s; | ||
4075 | a->num_bits -= s; | ||
4076 | return z->value[b]; | ||
4077 | } | ||
4078 | |||
4079 | stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z) | ||
4080 | { | ||
4081 | int b,s; | ||
4082 | if (a->num_bits < 16) stbi__fill_bits(a); | ||
4083 | b = z->fast[a->code_buffer & STBI__ZFAST_MASK]; | ||
4084 | if (b) { | ||
4085 | s = b >> 9; | ||
4086 | a->code_buffer >>= s; | ||
4087 | a->num_bits -= s; | ||
4088 | return b & 511; | ||
4089 | } | ||
4090 | return stbi__zhuffman_decode_slowpath(a, z); | ||
4091 | } | ||
4092 | |||
4093 | static int stbi__zexpand(stbi__zbuf *z, char *zout, int n) // need to make room for n bytes | ||
4094 | { | ||
4095 | char *q; | ||
4096 | int cur, limit, old_limit; | ||
4097 | z->zout = zout; | ||
4098 | if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG"); | ||
4099 | cur = (int) (z->zout - z->zout_start); | ||
4100 | limit = old_limit = (int) (z->zout_end - z->zout_start); | ||
4101 | while (cur + n > limit) | ||
4102 | limit *= 2; | ||
4103 | q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit); | ||
4104 | STBI_NOTUSED(old_limit); | ||
4105 | if (q == NULL) return stbi__err("outofmem", "Out of memory"); | ||
4106 | z->zout_start = q; | ||
4107 | z->zout = q + cur; | ||
4108 | z->zout_end = q + limit; | ||
4109 | return 1; | ||
4110 | } | ||
4111 | |||
4112 | static const int stbi__zlength_base[31] = { | ||
4113 | 3,4,5,6,7,8,9,10,11,13, | ||
4114 | 15,17,19,23,27,31,35,43,51,59, | ||
4115 | 67,83,99,115,131,163,195,227,258,0,0 }; | ||
4116 | |||
4117 | static const int stbi__zlength_extra[31]= | ||
4118 | { 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,0,0 }; | ||
4119 | |||
4120 | static const int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193, | ||
4121 | 257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0}; | ||
4122 | |||
4123 | static const int stbi__zdist_extra[32] = | ||
4124 | { 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}; | ||
4125 | |||
4126 | static int stbi__parse_huffman_block(stbi__zbuf *a) | ||
4127 | { | ||
4128 | char *zout = a->zout; | ||
4129 | for(;;) { | ||
4130 | int z = stbi__zhuffman_decode(a, &a->z_length); | ||
4131 | if (z < 256) { | ||
4132 | if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); // error in huffman codes | ||
4133 | if (zout >= a->zout_end) { | ||
4134 | if (!stbi__zexpand(a, zout, 1)) return 0; | ||
4135 | zout = a->zout; | ||
4136 | } | ||
4137 | *zout++ = (char) z; | ||
4138 | } else { | ||
4139 | stbi_uc *p; | ||
4140 | int len,dist; | ||
4141 | if (z == 256) { | ||
4142 | a->zout = zout; | ||
4143 | return 1; | ||
4144 | } | ||
4145 | z -= 257; | ||
4146 | len = stbi__zlength_base[z]; | ||
4147 | if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]); | ||
4148 | z = stbi__zhuffman_decode(a, &a->z_distance); | ||
4149 | if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); | ||
4150 | dist = stbi__zdist_base[z]; | ||
4151 | if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]); | ||
4152 | if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG"); | ||
4153 | if (zout + len > a->zout_end) { | ||
4154 | if (!stbi__zexpand(a, zout, len)) return 0; | ||
4155 | zout = a->zout; | ||
4156 | } | ||
4157 | p = (stbi_uc *) (zout - dist); | ||
4158 | if (dist == 1) { // run of one byte; common in images. | ||
4159 | stbi_uc v = *p; | ||
4160 | if (len) { do *zout++ = v; while (--len); } | ||
4161 | } else { | ||
4162 | if (len) { do *zout++ = *p++; while (--len); } | ||
4163 | } | ||
4164 | } | ||
4165 | } | ||
4166 | } | ||
4167 | |||
4168 | static int stbi__compute_huffman_codes(stbi__zbuf *a) | ||
4169 | { | ||
4170 | static const stbi_uc length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 }; | ||
4171 | stbi__zhuffman z_codelength; | ||
4172 | stbi_uc lencodes[286+32+137];//padding for maximum single op | ||
4173 | stbi_uc codelength_sizes[19]; | ||
4174 | int i,n; | ||
4175 | |||
4176 | int hlit = stbi__zreceive(a,5) + 257; | ||
4177 | int hdist = stbi__zreceive(a,5) + 1; | ||
4178 | int hclen = stbi__zreceive(a,4) + 4; | ||
4179 | int ntot = hlit + hdist; | ||
4180 | |||
4181 | memset(codelength_sizes, 0, sizeof(codelength_sizes)); | ||
4182 | for (i=0; i < hclen; ++i) { | ||
4183 | int s = stbi__zreceive(a,3); | ||
4184 | codelength_sizes[length_dezigzag[i]] = (stbi_uc) s; | ||
4185 | } | ||
4186 | if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0; | ||
4187 | |||
4188 | n = 0; | ||
4189 | while (n < ntot) { | ||
4190 | int c = stbi__zhuffman_decode(a, &z_codelength); | ||
4191 | if (c < 0 || c >= 19) return stbi__err("bad codelengths", "Corrupt PNG"); | ||
4192 | if (c < 16) | ||
4193 | lencodes[n++] = (stbi_uc) c; | ||
4194 | else { | ||
4195 | stbi_uc fill = 0; | ||
4196 | if (c == 16) { | ||
4197 | c = stbi__zreceive(a,2)+3; | ||
4198 | if (n == 0) return stbi__err("bad codelengths", "Corrupt PNG"); | ||
4199 | fill = lencodes[n-1]; | ||
4200 | } else if (c == 17) | ||
4201 | c = stbi__zreceive(a,3)+3; | ||
4202 | else { | ||
4203 | STBI_ASSERT(c == 18); | ||
4204 | c = stbi__zreceive(a,7)+11; | ||
4205 | } | ||
4206 | if (ntot - n < c) return stbi__err("bad codelengths", "Corrupt PNG"); | ||
4207 | memset(lencodes+n, fill, c); | ||
4208 | n += c; | ||
4209 | } | ||
4210 | } | ||
4211 | if (n != ntot) return stbi__err("bad codelengths","Corrupt PNG"); | ||
4212 | if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit)) return 0; | ||
4213 | if (!stbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0; | ||
4214 | return 1; | ||
4215 | } | ||
4216 | |||
4217 | static int stbi__parse_uncompressed_block(stbi__zbuf *a) | ||
4218 | { | ||
4219 | stbi_uc header[4]; | ||
4220 | int len,nlen,k; | ||
4221 | if (a->num_bits & 7) | ||
4222 | stbi__zreceive(a, a->num_bits & 7); // discard | ||
4223 | // drain the bit-packed data into header | ||
4224 | k = 0; | ||
4225 | while (a->num_bits > 0) { | ||
4226 | header[k++] = (stbi_uc) (a->code_buffer & 255); // suppress MSVC run-time check | ||
4227 | a->code_buffer >>= 8; | ||
4228 | a->num_bits -= 8; | ||
4229 | } | ||
4230 | STBI_ASSERT(a->num_bits == 0); | ||
4231 | // now fill header the normal way | ||
4232 | while (k < 4) | ||
4233 | header[k++] = stbi__zget8(a); | ||
4234 | len = header[1] * 256 + header[0]; | ||
4235 | nlen = header[3] * 256 + header[2]; | ||
4236 | if (nlen != (len ^ 0xffff)) return stbi__err("zlib corrupt","Corrupt PNG"); | ||
4237 | if (a->zbuffer + len > a->zbuffer_end) return stbi__err("read past buffer","Corrupt PNG"); | ||
4238 | if (a->zout + len > a->zout_end) | ||
4239 | if (!stbi__zexpand(a, a->zout, len)) return 0; | ||
4240 | memcpy(a->zout, a->zbuffer, len); | ||
4241 | a->zbuffer += len; | ||
4242 | a->zout += len; | ||
4243 | return 1; | ||
4244 | } | ||
4245 | |||
4246 | static int stbi__parse_zlib_header(stbi__zbuf *a) | ||
4247 | { | ||
4248 | int cmf = stbi__zget8(a); | ||
4249 | int cm = cmf & 15; | ||
4250 | /* int cinfo = cmf >> 4; */ | ||
4251 | int flg = stbi__zget8(a); | ||
4252 | if ((cmf*256+flg) % 31 != 0) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec | ||
4253 | if (flg & 32) return stbi__err("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png | ||
4254 | if (cm != 8) return stbi__err("bad compression","Corrupt PNG"); // DEFLATE required for png | ||
4255 | // window = 1 << (8 + cinfo)... but who cares, we fully buffer output | ||
4256 | return 1; | ||
4257 | } | ||
4258 | |||
4259 | static const stbi_uc stbi__zdefault_length[288] = | ||
4260 | { | ||
4261 | 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, | ||
4262 | 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, | ||
4263 | 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, | ||
4264 | 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, | ||
4265 | 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, | ||
4266 | 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, | ||
4267 | 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, | ||
4268 | 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, | ||
4269 | 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8 | ||
4270 | }; | ||
4271 | static const stbi_uc stbi__zdefault_distance[32] = | ||
4272 | { | ||
4273 | 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5 | ||
4274 | }; | ||
4275 | /* | ||
4276 | Init algorithm: | ||
4277 | { | ||
4278 | int i; // use <= to match clearly with spec | ||
4279 | for (i=0; i <= 143; ++i) stbi__zdefault_length[i] = 8; | ||
4280 | for ( ; i <= 255; ++i) stbi__zdefault_length[i] = 9; | ||
4281 | for ( ; i <= 279; ++i) stbi__zdefault_length[i] = 7; | ||
4282 | for ( ; i <= 287; ++i) stbi__zdefault_length[i] = 8; | ||
4283 | |||
4284 | for (i=0; i <= 31; ++i) stbi__zdefault_distance[i] = 5; | ||
4285 | } | ||
4286 | */ | ||
4287 | |||
4288 | static int stbi__parse_zlib(stbi__zbuf *a, int parse_header) | ||
4289 | { | ||
4290 | int final, type; | ||
4291 | if (parse_header) | ||
4292 | if (!stbi__parse_zlib_header(a)) return 0; | ||
4293 | a->num_bits = 0; | ||
4294 | a->code_buffer = 0; | ||
4295 | do { | ||
4296 | final = stbi__zreceive(a,1); | ||
4297 | type = stbi__zreceive(a,2); | ||
4298 | if (type == 0) { | ||
4299 | if (!stbi__parse_uncompressed_block(a)) return 0; | ||
4300 | } else if (type == 3) { | ||
4301 | return 0; | ||
4302 | } else { | ||
4303 | if (type == 1) { | ||
4304 | // use fixed code lengths | ||
4305 | if (!stbi__zbuild_huffman(&a->z_length , stbi__zdefault_length , 288)) return 0; | ||
4306 | if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance, 32)) return 0; | ||
4307 | } else { | ||
4308 | if (!stbi__compute_huffman_codes(a)) return 0; | ||
4309 | } | ||
4310 | if (!stbi__parse_huffman_block(a)) return 0; | ||
4311 | } | ||
4312 | } while (!final); | ||
4313 | return 1; | ||
4314 | } | ||
4315 | |||
4316 | static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header) | ||
4317 | { | ||
4318 | a->zout_start = obuf; | ||
4319 | a->zout = obuf; | ||
4320 | a->zout_end = obuf + olen; | ||
4321 | a->z_expandable = exp; | ||
4322 | |||
4323 | return stbi__parse_zlib(a, parse_header); | ||
4324 | } | ||
4325 | |||
4326 | STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen) | ||
4327 | { | ||
4328 | stbi__zbuf a; | ||
4329 | char *p = (char *) stbi__malloc(initial_size); | ||
4330 | if (p == NULL) return NULL; | ||
4331 | a.zbuffer = (stbi_uc *) buffer; | ||
4332 | a.zbuffer_end = (stbi_uc *) buffer + len; | ||
4333 | if (stbi__do_zlib(&a, p, initial_size, 1, 1)) { | ||
4334 | if (outlen) *outlen = (int) (a.zout - a.zout_start); | ||
4335 | return a.zout_start; | ||
4336 | } else { | ||
4337 | STBI_FREE(a.zout_start); | ||
4338 | return NULL; | ||
4339 | } | ||
4340 | } | ||
4341 | |||
4342 | STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen) | ||
4343 | { | ||
4344 | return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen); | ||
4345 | } | ||
4346 | |||
4347 | STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header) | ||
4348 | { | ||
4349 | stbi__zbuf a; | ||
4350 | char *p = (char *) stbi__malloc(initial_size); | ||
4351 | if (p == NULL) return NULL; | ||
4352 | a.zbuffer = (stbi_uc *) buffer; | ||
4353 | a.zbuffer_end = (stbi_uc *) buffer + len; | ||
4354 | if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) { | ||
4355 | if (outlen) *outlen = (int) (a.zout - a.zout_start); | ||
4356 | return a.zout_start; | ||
4357 | } else { | ||
4358 | STBI_FREE(a.zout_start); | ||
4359 | return NULL; | ||
4360 | } | ||
4361 | } | ||
4362 | |||
4363 | STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen) | ||
4364 | { | ||
4365 | stbi__zbuf a; | ||
4366 | a.zbuffer = (stbi_uc *) ibuffer; | ||
4367 | a.zbuffer_end = (stbi_uc *) ibuffer + ilen; | ||
4368 | if (stbi__do_zlib(&a, obuffer, olen, 0, 1)) | ||
4369 | return (int) (a.zout - a.zout_start); | ||
4370 | else | ||
4371 | return -1; | ||
4372 | } | ||
4373 | |||
4374 | STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen) | ||
4375 | { | ||
4376 | stbi__zbuf a; | ||
4377 | char *p = (char *) stbi__malloc(16384); | ||
4378 | if (p == NULL) return NULL; | ||
4379 | a.zbuffer = (stbi_uc *) buffer; | ||
4380 | a.zbuffer_end = (stbi_uc *) buffer+len; | ||
4381 | if (stbi__do_zlib(&a, p, 16384, 1, 0)) { | ||
4382 | if (outlen) *outlen = (int) (a.zout - a.zout_start); | ||
4383 | return a.zout_start; | ||
4384 | } else { | ||
4385 | STBI_FREE(a.zout_start); | ||
4386 | return NULL; | ||
4387 | } | ||
4388 | } | ||
4389 | |||
4390 | STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen) | ||
4391 | { | ||
4392 | stbi__zbuf a; | ||
4393 | a.zbuffer = (stbi_uc *) ibuffer; | ||
4394 | a.zbuffer_end = (stbi_uc *) ibuffer + ilen; | ||
4395 | if (stbi__do_zlib(&a, obuffer, olen, 0, 0)) | ||
4396 | return (int) (a.zout - a.zout_start); | ||
4397 | else | ||
4398 | return -1; | ||
4399 | } | ||
4400 | #endif | ||
4401 | |||
4402 | // public domain "baseline" PNG decoder v0.10 Sean Barrett 2006-11-18 | ||
4403 | // simple implementation | ||
4404 | // - only 8-bit samples | ||
4405 | // - no CRC checking | ||
4406 | // - allocates lots of intermediate memory | ||
4407 | // - avoids problem of streaming data between subsystems | ||
4408 | // - avoids explicit window management | ||
4409 | // performance | ||
4410 | // - uses stb_zlib, a PD zlib implementation with fast huffman decoding | ||
4411 | |||
4412 | #ifndef STBI_NO_PNG | ||
4413 | typedef struct | ||
4414 | { | ||
4415 | stbi__uint32 length; | ||
4416 | stbi__uint32 type; | ||
4417 | } stbi__pngchunk; | ||
4418 | |||
4419 | static stbi__pngchunk stbi__get_chunk_header(stbi__context *s) | ||
4420 | { | ||
4421 | stbi__pngchunk c; | ||
4422 | c.length = stbi__get32be(s); | ||
4423 | c.type = stbi__get32be(s); | ||
4424 | return c; | ||
4425 | } | ||
4426 | |||
4427 | static int stbi__check_png_header(stbi__context *s) | ||
4428 | { | ||
4429 | static const stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 }; | ||
4430 | int i; | ||
4431 | for (i=0; i < 8; ++i) | ||
4432 | if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a PNG"); | ||
4433 | return 1; | ||
4434 | } | ||
4435 | |||
4436 | typedef struct | ||
4437 | { | ||
4438 | stbi__context *s; | ||
4439 | stbi_uc *idata, *expanded, *out; | ||
4440 | int depth; | ||
4441 | } stbi__png; | ||
4442 | |||
4443 | |||
4444 | enum { | ||
4445 | STBI__F_none=0, | ||
4446 | STBI__F_sub=1, | ||
4447 | STBI__F_up=2, | ||
4448 | STBI__F_avg=3, | ||
4449 | STBI__F_paeth=4, | ||
4450 | // synthetic filters used for first scanline to avoid needing a dummy row of 0s | ||
4451 | STBI__F_avg_first, | ||
4452 | STBI__F_paeth_first | ||
4453 | }; | ||
4454 | |||
4455 | static stbi_uc first_row_filter[5] = | ||
4456 | { | ||
4457 | STBI__F_none, | ||
4458 | STBI__F_sub, | ||
4459 | STBI__F_none, | ||
4460 | STBI__F_avg_first, | ||
4461 | STBI__F_paeth_first | ||
4462 | }; | ||
4463 | |||
4464 | static int stbi__paeth(int a, int b, int c) | ||
4465 | { | ||
4466 | int p = a + b - c; | ||
4467 | int pa = abs(p-a); | ||
4468 | int pb = abs(p-b); | ||
4469 | int pc = abs(p-c); | ||
4470 | if (pa <= pb && pa <= pc) return a; | ||
4471 | if (pb <= pc) return b; | ||
4472 | return c; | ||
4473 | } | ||
4474 | |||
4475 | static const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 }; | ||
4476 | |||
4477 | // create the png data from post-deflated data | ||
4478 | static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y, int depth, int color) | ||
4479 | { | ||
4480 | int bytes = (depth == 16? 2 : 1); | ||
4481 | stbi__context *s = a->s; | ||
4482 | stbi__uint32 i,j,stride = x*out_n*bytes; | ||
4483 | stbi__uint32 img_len, img_width_bytes; | ||
4484 | int k; | ||
4485 | int img_n = s->img_n; // copy it into a local for later | ||
4486 | |||
4487 | int output_bytes = out_n*bytes; | ||
4488 | int filter_bytes = img_n*bytes; | ||
4489 | int width = x; | ||
4490 | |||
4491 | STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1); | ||
4492 | a->out = (stbi_uc *) stbi__malloc_mad3(x, y, output_bytes, 0); // extra bytes to write off the end into | ||
4493 | if (!a->out) return stbi__err("outofmem", "Out of memory"); | ||
4494 | |||
4495 | if (!stbi__mad3sizes_valid(img_n, x, depth, 7)) return stbi__err("too large", "Corrupt PNG"); | ||
4496 | img_width_bytes = (((img_n * x * depth) + 7) >> 3); | ||
4497 | img_len = (img_width_bytes + 1) * y; | ||
4498 | |||
4499 | // we used to check for exact match between raw_len and img_len on non-interlaced PNGs, | ||
4500 | // but issue #276 reported a PNG in the wild that had extra data at the end (all zeros), | ||
4501 | // so just check for raw_len < img_len always. | ||
4502 | if (raw_len < img_len) return stbi__err("not enough pixels","Corrupt PNG"); | ||
4503 | |||
4504 | for (j=0; j < y; ++j) { | ||
4505 | stbi_uc *cur = a->out + stride*j; | ||
4506 | stbi_uc *prior; | ||
4507 | int filter = *raw++; | ||
4508 | |||
4509 | if (filter > 4) | ||
4510 | return stbi__err("invalid filter","Corrupt PNG"); | ||
4511 | |||
4512 | if (depth < 8) { | ||
4513 | STBI_ASSERT(img_width_bytes <= x); | ||
4514 | cur += x*out_n - img_width_bytes; // store output to the rightmost img_len bytes, so we can decode in place | ||
4515 | filter_bytes = 1; | ||
4516 | width = img_width_bytes; | ||
4517 | } | ||
4518 | prior = cur - stride; // bugfix: need to compute this after 'cur +=' computation above | ||
4519 | |||
4520 | // if first row, use special filter that doesn't sample previous row | ||
4521 | if (j == 0) filter = first_row_filter[filter]; | ||
4522 | |||
4523 | // handle first byte explicitly | ||
4524 | for (k=0; k < filter_bytes; ++k) { | ||
4525 | switch (filter) { | ||
4526 | case STBI__F_none : cur[k] = raw[k]; break; | ||
4527 | case STBI__F_sub : cur[k] = raw[k]; break; | ||
4528 | case STBI__F_up : cur[k] = STBI__BYTECAST(raw[k] + prior[k]); break; | ||
4529 | case STBI__F_avg : cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1)); break; | ||
4530 | case STBI__F_paeth : cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(0,prior[k],0)); break; | ||
4531 | case STBI__F_avg_first : cur[k] = raw[k]; break; | ||
4532 | case STBI__F_paeth_first: cur[k] = raw[k]; break; | ||
4533 | } | ||
4534 | } | ||
4535 | |||
4536 | if (depth == 8) { | ||
4537 | if (img_n != out_n) | ||
4538 | cur[img_n] = 255; // first pixel | ||
4539 | raw += img_n; | ||
4540 | cur += out_n; | ||
4541 | prior += out_n; | ||
4542 | } else if (depth == 16) { | ||
4543 | if (img_n != out_n) { | ||
4544 | cur[filter_bytes] = 255; // first pixel top byte | ||
4545 | cur[filter_bytes+1] = 255; // first pixel bottom byte | ||
4546 | } | ||
4547 | raw += filter_bytes; | ||
4548 | cur += output_bytes; | ||
4549 | prior += output_bytes; | ||
4550 | } else { | ||
4551 | raw += 1; | ||
4552 | cur += 1; | ||
4553 | prior += 1; | ||
4554 | } | ||
4555 | |||
4556 | // this is a little gross, so that we don't switch per-pixel or per-component | ||
4557 | if (depth < 8 || img_n == out_n) { | ||
4558 | int nk = (width - 1)*filter_bytes; | ||
4559 | #define STBI__CASE(f) \ | ||
4560 | case f: \ | ||
4561 | for (k=0; k < nk; ++k) | ||
4562 | switch (filter) { | ||
4563 | // "none" filter turns into a memcpy here; make that explicit. | ||
4564 | case STBI__F_none: memcpy(cur, raw, nk); break; | ||
4565 | STBI__CASE(STBI__F_sub) { cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]); } break; | ||
4566 | STBI__CASE(STBI__F_up) { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); } break; | ||
4567 | STBI__CASE(STBI__F_avg) { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1)); } break; | ||
4568 | STBI__CASE(STBI__F_paeth) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],prior[k],prior[k-filter_bytes])); } break; | ||
4569 | STBI__CASE(STBI__F_avg_first) { cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1)); } break; | ||
4570 | STBI__CASE(STBI__F_paeth_first) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],0,0)); } break; | ||
4571 | } | ||
4572 | #undef STBI__CASE | ||
4573 | raw += nk; | ||
4574 | } else { | ||
4575 | STBI_ASSERT(img_n+1 == out_n); | ||
4576 | #define STBI__CASE(f) \ | ||
4577 | case f: \ | ||
4578 | for (i=x-1; i >= 1; --i, cur[filter_bytes]=255,raw+=filter_bytes,cur+=output_bytes,prior+=output_bytes) \ | ||
4579 | for (k=0; k < filter_bytes; ++k) | ||
4580 | switch (filter) { | ||
4581 | STBI__CASE(STBI__F_none) { cur[k] = raw[k]; } break; | ||
4582 | STBI__CASE(STBI__F_sub) { cur[k] = STBI__BYTECAST(raw[k] + cur[k- output_bytes]); } break; | ||
4583 | STBI__CASE(STBI__F_up) { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); } break; | ||
4584 | STBI__CASE(STBI__F_avg) { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k- output_bytes])>>1)); } break; | ||
4585 | STBI__CASE(STBI__F_paeth) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k- output_bytes],prior[k],prior[k- output_bytes])); } break; | ||
4586 | STBI__CASE(STBI__F_avg_first) { cur[k] = STBI__BYTECAST(raw[k] + (cur[k- output_bytes] >> 1)); } break; | ||
4587 | STBI__CASE(STBI__F_paeth_first) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k- output_bytes],0,0)); } break; | ||
4588 | } | ||
4589 | #undef STBI__CASE | ||
4590 | |||
4591 | // the loop above sets the high byte of the pixels' alpha, but for | ||
4592 | // 16 bit png files we also need the low byte set. we'll do that here. | ||
4593 | if (depth == 16) { | ||
4594 | cur = a->out + stride*j; // start at the beginning of the row again | ||
4595 | for (i=0; i < x; ++i,cur+=output_bytes) { | ||
4596 | cur[filter_bytes+1] = 255; | ||
4597 | } | ||
4598 | } | ||
4599 | } | ||
4600 | } | ||
4601 | |||
4602 | // we make a separate pass to expand bits to pixels; for performance, | ||
4603 | // this could run two scanlines behind the above code, so it won't | ||
4604 | // intefere with filtering but will still be in the cache. | ||
4605 | if (depth < 8) { | ||
4606 | for (j=0; j < y; ++j) { | ||
4607 | stbi_uc *cur = a->out + stride*j; | ||
4608 | stbi_uc *in = a->out + stride*j + x*out_n - img_width_bytes; | ||
4609 | // unpack 1/2/4-bit into a 8-bit buffer. allows us to keep the common 8-bit path optimal at minimal cost for 1/2/4-bit | ||
4610 | // png guarante byte alignment, if width is not multiple of 8/4/2 we'll decode dummy trailing data that will be skipped in the later loop | ||
4611 | stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1; // scale grayscale values to 0..255 range | ||
4612 | |||
4613 | // note that the final byte might overshoot and write more data than desired. | ||
4614 | // we can allocate enough data that this never writes out of memory, but it | ||
4615 | // could also overwrite the next scanline. can it overwrite non-empty data | ||
4616 | // on the next scanline? yes, consider 1-pixel-wide scanlines with 1-bit-per-pixel. | ||
4617 | // so we need to explicitly clamp the final ones | ||
4618 | |||
4619 | if (depth == 4) { | ||
4620 | for (k=x*img_n; k >= 2; k-=2, ++in) { | ||
4621 | *cur++ = scale * ((*in >> 4) ); | ||
4622 | *cur++ = scale * ((*in ) & 0x0f); | ||
4623 | } | ||
4624 | if (k > 0) *cur++ = scale * ((*in >> 4) ); | ||
4625 | } else if (depth == 2) { | ||
4626 | for (k=x*img_n; k >= 4; k-=4, ++in) { | ||
4627 | *cur++ = scale * ((*in >> 6) ); | ||
4628 | *cur++ = scale * ((*in >> 4) & 0x03); | ||
4629 | *cur++ = scale * ((*in >> 2) & 0x03); | ||
4630 | *cur++ = scale * ((*in ) & 0x03); | ||
4631 | } | ||
4632 | if (k > 0) *cur++ = scale * ((*in >> 6) ); | ||
4633 | if (k > 1) *cur++ = scale * ((*in >> 4) & 0x03); | ||
4634 | if (k > 2) *cur++ = scale * ((*in >> 2) & 0x03); | ||
4635 | } else if (depth == 1) { | ||
4636 | for (k=x*img_n; k >= 8; k-=8, ++in) { | ||
4637 | *cur++ = scale * ((*in >> 7) ); | ||
4638 | *cur++ = scale * ((*in >> 6) & 0x01); | ||
4639 | *cur++ = scale * ((*in >> 5) & 0x01); | ||
4640 | *cur++ = scale * ((*in >> 4) & 0x01); | ||
4641 | *cur++ = scale * ((*in >> 3) & 0x01); | ||
4642 | *cur++ = scale * ((*in >> 2) & 0x01); | ||
4643 | *cur++ = scale * ((*in >> 1) & 0x01); | ||
4644 | *cur++ = scale * ((*in ) & 0x01); | ||
4645 | } | ||
4646 | if (k > 0) *cur++ = scale * ((*in >> 7) ); | ||
4647 | if (k > 1) *cur++ = scale * ((*in >> 6) & 0x01); | ||
4648 | if (k > 2) *cur++ = scale * ((*in >> 5) & 0x01); | ||
4649 | if (k > 3) *cur++ = scale * ((*in >> 4) & 0x01); | ||
4650 | if (k > 4) *cur++ = scale * ((*in >> 3) & 0x01); | ||
4651 | if (k > 5) *cur++ = scale * ((*in >> 2) & 0x01); | ||
4652 | if (k > 6) *cur++ = scale * ((*in >> 1) & 0x01); | ||
4653 | } | ||
4654 | if (img_n != out_n) { | ||
4655 | int q; | ||
4656 | // insert alpha = 255 | ||
4657 | cur = a->out + stride*j; | ||
4658 | if (img_n == 1) { | ||
4659 | for (q=x-1; q >= 0; --q) { | ||
4660 | cur[q*2+1] = 255; | ||
4661 | cur[q*2+0] = cur[q]; | ||
4662 | } | ||
4663 | } else { | ||
4664 | STBI_ASSERT(img_n == 3); | ||
4665 | for (q=x-1; q >= 0; --q) { | ||
4666 | cur[q*4+3] = 255; | ||
4667 | cur[q*4+2] = cur[q*3+2]; | ||
4668 | cur[q*4+1] = cur[q*3+1]; | ||
4669 | cur[q*4+0] = cur[q*3+0]; | ||
4670 | } | ||
4671 | } | ||
4672 | } | ||
4673 | } | ||
4674 | } else if (depth == 16) { | ||
4675 | // force the image data from big-endian to platform-native. | ||
4676 | // this is done in a separate pass due to the decoding relying | ||
4677 | // on the data being untouched, but could probably be done | ||
4678 | // per-line during decode if care is taken. | ||
4679 | stbi_uc *cur = a->out; | ||
4680 | stbi__uint16 *cur16 = (stbi__uint16*)cur; | ||
4681 | |||
4682 | for(i=0; i < x*y*out_n; ++i,cur16++,cur+=2) { | ||
4683 | *cur16 = (cur[0] << 8) | cur[1]; | ||
4684 | } | ||
4685 | } | ||
4686 | |||
4687 | return 1; | ||
4688 | } | ||
4689 | |||
4690 | static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced) | ||
4691 | { | ||
4692 | int bytes = (depth == 16 ? 2 : 1); | ||
4693 | int out_bytes = out_n * bytes; | ||
4694 | stbi_uc *final; | ||
4695 | int p; | ||
4696 | if (!interlaced) | ||
4697 | return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color); | ||
4698 | |||
4699 | // de-interlacing | ||
4700 | final = (stbi_uc *) stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0); | ||
4701 | for (p=0; p < 7; ++p) { | ||
4702 | int xorig[] = { 0,4,0,2,0,1,0 }; | ||
4703 | int yorig[] = { 0,0,4,0,2,0,1 }; | ||
4704 | int xspc[] = { 8,8,4,4,2,2,1 }; | ||
4705 | int yspc[] = { 8,8,8,4,4,2,2 }; | ||
4706 | int i,j,x,y; | ||
4707 | // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1 | ||
4708 | x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p]; | ||
4709 | y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p]; | ||
4710 | if (x && y) { | ||
4711 | stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y; | ||
4712 | if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) { | ||
4713 | STBI_FREE(final); | ||
4714 | return 0; | ||
4715 | } | ||
4716 | for (j=0; j < y; ++j) { | ||
4717 | for (i=0; i < x; ++i) { | ||
4718 | int out_y = j*yspc[p]+yorig[p]; | ||
4719 | int out_x = i*xspc[p]+xorig[p]; | ||
4720 | memcpy(final + out_y*a->s->img_x*out_bytes + out_x*out_bytes, | ||
4721 | a->out + (j*x+i)*out_bytes, out_bytes); | ||
4722 | } | ||
4723 | } | ||
4724 | STBI_FREE(a->out); | ||
4725 | image_data += img_len; | ||
4726 | image_data_len -= img_len; | ||
4727 | } | ||
4728 | } | ||
4729 | a->out = final; | ||
4730 | |||
4731 | return 1; | ||
4732 | } | ||
4733 | |||
4734 | static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n) | ||
4735 | { | ||
4736 | stbi__context *s = z->s; | ||
4737 | stbi__uint32 i, pixel_count = s->img_x * s->img_y; | ||
4738 | stbi_uc *p = z->out; | ||
4739 | |||
4740 | // compute color-based transparency, assuming we've | ||
4741 | // already got 255 as the alpha value in the output | ||
4742 | STBI_ASSERT(out_n == 2 || out_n == 4); | ||
4743 | |||
4744 | if (out_n == 2) { | ||
4745 | for (i=0; i < pixel_count; ++i) { | ||
4746 | p[1] = (p[0] == tc[0] ? 0 : 255); | ||
4747 | p += 2; | ||
4748 | } | ||
4749 | } else { | ||
4750 | for (i=0; i < pixel_count; ++i) { | ||
4751 | if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) | ||
4752 | p[3] = 0; | ||
4753 | p += 4; | ||
4754 | } | ||
4755 | } | ||
4756 | return 1; | ||
4757 | } | ||
4758 | |||
4759 | static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n) | ||
4760 | { | ||
4761 | stbi__context *s = z->s; | ||
4762 | stbi__uint32 i, pixel_count = s->img_x * s->img_y; | ||
4763 | stbi__uint16 *p = (stbi__uint16*) z->out; | ||
4764 | |||
4765 | // compute color-based transparency, assuming we've | ||
4766 | // already got 65535 as the alpha value in the output | ||
4767 | STBI_ASSERT(out_n == 2 || out_n == 4); | ||
4768 | |||
4769 | if (out_n == 2) { | ||
4770 | for (i = 0; i < pixel_count; ++i) { | ||
4771 | p[1] = (p[0] == tc[0] ? 0 : 65535); | ||
4772 | p += 2; | ||
4773 | } | ||
4774 | } else { | ||
4775 | for (i = 0; i < pixel_count; ++i) { | ||
4776 | if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) | ||
4777 | p[3] = 0; | ||
4778 | p += 4; | ||
4779 | } | ||
4780 | } | ||
4781 | return 1; | ||
4782 | } | ||
4783 | |||
4784 | static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n) | ||
4785 | { | ||
4786 | stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y; | ||
4787 | stbi_uc *p, *temp_out, *orig = a->out; | ||
4788 | |||
4789 | p = (stbi_uc *) stbi__malloc_mad2(pixel_count, pal_img_n, 0); | ||
4790 | if (p == NULL) return stbi__err("outofmem", "Out of memory"); | ||
4791 | |||
4792 | // between here and free(out) below, exitting would leak | ||
4793 | temp_out = p; | ||
4794 | |||
4795 | if (pal_img_n == 3) { | ||
4796 | for (i=0; i < pixel_count; ++i) { | ||
4797 | int n = orig[i]*4; | ||
4798 | p[0] = palette[n ]; | ||
4799 | p[1] = palette[n+1]; | ||
4800 | p[2] = palette[n+2]; | ||
4801 | p += 3; | ||
4802 | } | ||
4803 | } else { | ||
4804 | for (i=0; i < pixel_count; ++i) { | ||
4805 | int n = orig[i]*4; | ||
4806 | p[0] = palette[n ]; | ||
4807 | p[1] = palette[n+1]; | ||
4808 | p[2] = palette[n+2]; | ||
4809 | p[3] = palette[n+3]; | ||
4810 | p += 4; | ||
4811 | } | ||
4812 | } | ||
4813 | STBI_FREE(a->out); | ||
4814 | a->out = temp_out; | ||
4815 | |||
4816 | STBI_NOTUSED(len); | ||
4817 | |||
4818 | return 1; | ||
4819 | } | ||
4820 | |||
4821 | static int stbi__unpremultiply_on_load = 0; | ||
4822 | static int stbi__de_iphone_flag = 0; | ||
4823 | |||
4824 | STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply) | ||
4825 | { | ||
4826 | stbi__unpremultiply_on_load = flag_true_if_should_unpremultiply; | ||
4827 | } | ||
4828 | |||
4829 | STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert) | ||
4830 | { | ||
4831 | stbi__de_iphone_flag = flag_true_if_should_convert; | ||
4832 | } | ||
4833 | |||
4834 | static void stbi__de_iphone(stbi__png *z) | ||
4835 | { | ||
4836 | stbi__context *s = z->s; | ||
4837 | stbi__uint32 i, pixel_count = s->img_x * s->img_y; | ||
4838 | stbi_uc *p = z->out; | ||
4839 | |||
4840 | if (s->img_out_n == 3) { // convert bgr to rgb | ||
4841 | for (i=0; i < pixel_count; ++i) { | ||
4842 | stbi_uc t = p[0]; | ||
4843 | p[0] = p[2]; | ||
4844 | p[2] = t; | ||
4845 | p += 3; | ||
4846 | } | ||
4847 | } else { | ||
4848 | STBI_ASSERT(s->img_out_n == 4); | ||
4849 | if (stbi__unpremultiply_on_load) { | ||
4850 | // convert bgr to rgb and unpremultiply | ||
4851 | for (i=0; i < pixel_count; ++i) { | ||
4852 | stbi_uc a = p[3]; | ||
4853 | stbi_uc t = p[0]; | ||
4854 | if (a) { | ||
4855 | stbi_uc half = a / 2; | ||
4856 | p[0] = (p[2] * 255 + half) / a; | ||
4857 | p[1] = (p[1] * 255 + half) / a; | ||
4858 | p[2] = ( t * 255 + half) / a; | ||
4859 | } else { | ||
4860 | p[0] = p[2]; | ||
4861 | p[2] = t; | ||
4862 | } | ||
4863 | p += 4; | ||
4864 | } | ||
4865 | } else { | ||
4866 | // convert bgr to rgb | ||
4867 | for (i=0; i < pixel_count; ++i) { | ||
4868 | stbi_uc t = p[0]; | ||
4869 | p[0] = p[2]; | ||
4870 | p[2] = t; | ||
4871 | p += 4; | ||
4872 | } | ||
4873 | } | ||
4874 | } | ||
4875 | } | ||
4876 | |||
4877 | #define STBI__PNG_TYPE(a,b,c,d) (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d)) | ||
4878 | |||
4879 | static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp) | ||
4880 | { | ||
4881 | stbi_uc palette[1024], pal_img_n=0; | ||
4882 | stbi_uc has_trans=0, tc[3]={0}; | ||
4883 | stbi__uint16 tc16[3]; | ||
4884 | stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0; | ||
4885 | int first=1,k,interlace=0, color=0, is_iphone=0; | ||
4886 | stbi__context *s = z->s; | ||
4887 | |||
4888 | z->expanded = NULL; | ||
4889 | z->idata = NULL; | ||
4890 | z->out = NULL; | ||
4891 | |||
4892 | if (!stbi__check_png_header(s)) return 0; | ||
4893 | |||
4894 | if (scan == STBI__SCAN_type) return 1; | ||
4895 | |||
4896 | for (;;) { | ||
4897 | stbi__pngchunk c = stbi__get_chunk_header(s); | ||
4898 | switch (c.type) { | ||
4899 | case STBI__PNG_TYPE('C','g','B','I'): | ||
4900 | is_iphone = 1; | ||
4901 | stbi__skip(s, c.length); | ||
4902 | break; | ||
4903 | case STBI__PNG_TYPE('I','H','D','R'): { | ||
4904 | int comp,filter; | ||
4905 | if (!first) return stbi__err("multiple IHDR","Corrupt PNG"); | ||
4906 | first = 0; | ||
4907 | if (c.length != 13) return stbi__err("bad IHDR len","Corrupt PNG"); | ||
4908 | s->img_x = stbi__get32be(s); if (s->img_x > (1 << 24)) return stbi__err("too large","Very large image (corrupt?)"); | ||
4909 | s->img_y = stbi__get32be(s); if (s->img_y > (1 << 24)) return stbi__err("too large","Very large image (corrupt?)"); | ||
4910 | z->depth = stbi__get8(s); if (z->depth != 1 && z->depth != 2 && z->depth != 4 && z->depth != 8 && z->depth != 16) return stbi__err("1/2/4/8/16-bit only","PNG not supported: 1/2/4/8/16-bit only"); | ||
4911 | color = stbi__get8(s); if (color > 6) return stbi__err("bad ctype","Corrupt PNG"); | ||
4912 | if (color == 3 && z->depth == 16) return stbi__err("bad ctype","Corrupt PNG"); | ||
4913 | if (color == 3) pal_img_n = 3; else if (color & 1) return stbi__err("bad ctype","Corrupt PNG"); | ||
4914 | comp = stbi__get8(s); if (comp) return stbi__err("bad comp method","Corrupt PNG"); | ||
4915 | filter= stbi__get8(s); if (filter) return stbi__err("bad filter method","Corrupt PNG"); | ||
4916 | interlace = stbi__get8(s); if (interlace>1) return stbi__err("bad interlace method","Corrupt PNG"); | ||
4917 | if (!s->img_x || !s->img_y) return stbi__err("0-pixel image","Corrupt PNG"); | ||
4918 | if (!pal_img_n) { | ||
4919 | s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0); | ||
4920 | if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode"); | ||
4921 | if (scan == STBI__SCAN_header) return 1; | ||
4922 | } else { | ||
4923 | // if paletted, then pal_n is our final components, and | ||
4924 | // img_n is # components to decompress/filter. | ||
4925 | s->img_n = 1; | ||
4926 | if ((1 << 30) / s->img_x / 4 < s->img_y) return stbi__err("too large","Corrupt PNG"); | ||
4927 | // if SCAN_header, have to scan to see if we have a tRNS | ||
4928 | } | ||
4929 | break; | ||
4930 | } | ||
4931 | |||
4932 | case STBI__PNG_TYPE('P','L','T','E'): { | ||
4933 | if (first) return stbi__err("first not IHDR", "Corrupt PNG"); | ||
4934 | if (c.length > 256*3) return stbi__err("invalid PLTE","Corrupt PNG"); | ||
4935 | pal_len = c.length / 3; | ||
4936 | if (pal_len * 3 != c.length) return stbi__err("invalid PLTE","Corrupt PNG"); | ||
4937 | for (i=0; i < pal_len; ++i) { | ||
4938 | palette[i*4+0] = stbi__get8(s); | ||
4939 | palette[i*4+1] = stbi__get8(s); | ||
4940 | palette[i*4+2] = stbi__get8(s); | ||
4941 | palette[i*4+3] = 255; | ||
4942 | } | ||
4943 | break; | ||
4944 | } | ||
4945 | |||
4946 | case STBI__PNG_TYPE('t','R','N','S'): { | ||
4947 | if (first) return stbi__err("first not IHDR", "Corrupt PNG"); | ||
4948 | if (z->idata) return stbi__err("tRNS after IDAT","Corrupt PNG"); | ||
4949 | if (pal_img_n) { | ||
4950 | if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; } | ||
4951 | if (pal_len == 0) return stbi__err("tRNS before PLTE","Corrupt PNG"); | ||
4952 | if (c.length > pal_len) return stbi__err("bad tRNS len","Corrupt PNG"); | ||
4953 | pal_img_n = 4; | ||
4954 | for (i=0; i < c.length; ++i) | ||
4955 | palette[i*4+3] = stbi__get8(s); | ||
4956 | } else { | ||
4957 | if (!(s->img_n & 1)) return stbi__err("tRNS with alpha","Corrupt PNG"); | ||
4958 | if (c.length != (stbi__uint32) s->img_n*2) return stbi__err("bad tRNS len","Corrupt PNG"); | ||
4959 | has_trans = 1; | ||
4960 | if (z->depth == 16) { | ||
4961 | for (k = 0; k < s->img_n; ++k) tc16[k] = (stbi__uint16)stbi__get16be(s); // copy the values as-is | ||
4962 | } else { | ||
4963 | for (k = 0; k < s->img_n; ++k) tc[k] = (stbi_uc)(stbi__get16be(s) & 255) * stbi__depth_scale_table[z->depth]; // non 8-bit images will be larger | ||
4964 | } | ||
4965 | } | ||
4966 | break; | ||
4967 | } | ||
4968 | |||
4969 | case STBI__PNG_TYPE('I','D','A','T'): { | ||
4970 | if (first) return stbi__err("first not IHDR", "Corrupt PNG"); | ||
4971 | if (pal_img_n && !pal_len) return stbi__err("no PLTE","Corrupt PNG"); | ||
4972 | if (scan == STBI__SCAN_header) { s->img_n = pal_img_n; return 1; } | ||
4973 | if ((int)(ioff + c.length) < (int)ioff) return 0; | ||
4974 | if (ioff + c.length > idata_limit) { | ||
4975 | stbi__uint32 idata_limit_old = idata_limit; | ||
4976 | stbi_uc *p; | ||
4977 | if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096; | ||
4978 | while (ioff + c.length > idata_limit) | ||
4979 | idata_limit *= 2; | ||
4980 | STBI_NOTUSED(idata_limit_old); | ||
4981 | p = (stbi_uc *) STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory"); | ||
4982 | z->idata = p; | ||
4983 | } | ||
4984 | if (!stbi__getn(s, z->idata+ioff,c.length)) return stbi__err("outofdata","Corrupt PNG"); | ||
4985 | ioff += c.length; | ||
4986 | break; | ||
4987 | } | ||
4988 | |||
4989 | case STBI__PNG_TYPE('I','E','N','D'): { | ||
4990 | stbi__uint32 raw_len, bpl; | ||
4991 | if (first) return stbi__err("first not IHDR", "Corrupt PNG"); | ||
4992 | if (scan != STBI__SCAN_load) return 1; | ||
4993 | if (z->idata == NULL) return stbi__err("no IDAT","Corrupt PNG"); | ||
4994 | // initial guess for decoded data size to avoid unnecessary reallocs | ||
4995 | bpl = (s->img_x * z->depth + 7) / 8; // bytes per line, per component | ||
4996 | raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */; | ||
4997 | z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, raw_len, (int *) &raw_len, !is_iphone); | ||
4998 | if (z->expanded == NULL) return 0; // zlib should set error | ||
4999 | STBI_FREE(z->idata); z->idata = NULL; | ||
5000 | if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans) | ||
5001 | s->img_out_n = s->img_n+1; | ||
5002 | else | ||
5003 | s->img_out_n = s->img_n; | ||
5004 | if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, color, interlace)) return 0; | ||
5005 | if (has_trans) { | ||
5006 | if (z->depth == 16) { | ||
5007 | if (!stbi__compute_transparency16(z, tc16, s->img_out_n)) return 0; | ||
5008 | } else { | ||
5009 | if (!stbi__compute_transparency(z, tc, s->img_out_n)) return 0; | ||
5010 | } | ||
5011 | } | ||
5012 | if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2) | ||
5013 | stbi__de_iphone(z); | ||
5014 | if (pal_img_n) { | ||
5015 | // pal_img_n == 3 or 4 | ||
5016 | s->img_n = pal_img_n; // record the actual colors we had | ||
5017 | s->img_out_n = pal_img_n; | ||
5018 | if (req_comp >= 3) s->img_out_n = req_comp; | ||
5019 | if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n)) | ||
5020 | return 0; | ||
5021 | } else if (has_trans) { | ||
5022 | // non-paletted image with tRNS -> source image has (constant) alpha | ||
5023 | ++s->img_n; | ||
5024 | } | ||
5025 | STBI_FREE(z->expanded); z->expanded = NULL; | ||
5026 | // end of PNG chunk, read and skip CRC | ||
5027 | stbi__get32be(s); | ||
5028 | return 1; | ||
5029 | } | ||
5030 | |||
5031 | default: | ||
5032 | // if critical, fail | ||
5033 | if (first) return stbi__err("first not IHDR", "Corrupt PNG"); | ||
5034 | if ((c.type & (1 << 29)) == 0) { | ||
5035 | #ifndef STBI_NO_FAILURE_STRINGS | ||
5036 | // not threadsafe | ||
5037 | static char invalid_chunk[] = "XXXX PNG chunk not known"; | ||
5038 | invalid_chunk[0] = STBI__BYTECAST(c.type >> 24); | ||
5039 | invalid_chunk[1] = STBI__BYTECAST(c.type >> 16); | ||
5040 | invalid_chunk[2] = STBI__BYTECAST(c.type >> 8); | ||
5041 | invalid_chunk[3] = STBI__BYTECAST(c.type >> 0); | ||
5042 | #endif | ||
5043 | return stbi__err(invalid_chunk, "PNG not supported: unknown PNG chunk type"); | ||
5044 | } | ||
5045 | stbi__skip(s, c.length); | ||
5046 | break; | ||
5047 | } | ||
5048 | // end of PNG chunk, read and skip CRC | ||
5049 | stbi__get32be(s); | ||
5050 | } | ||
5051 | } | ||
5052 | |||
5053 | static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, stbi__result_info *ri) | ||
5054 | { | ||
5055 | void *result=NULL; | ||
5056 | if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); | ||
5057 | if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) { | ||
5058 | if (p->depth < 8) | ||
5059 | ri->bits_per_channel = 8; | ||
5060 | else | ||
5061 | ri->bits_per_channel = p->depth; | ||
5062 | result = p->out; | ||
5063 | p->out = NULL; | ||
5064 | if (req_comp && req_comp != p->s->img_out_n) { | ||
5065 | if (ri->bits_per_channel == 8) | ||
5066 | result = stbi__convert_format((unsigned char *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); | ||
5067 | else | ||
5068 | result = stbi__convert_format16((stbi__uint16 *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); | ||
5069 | p->s->img_out_n = req_comp; | ||
5070 | if (result == NULL) return result; | ||
5071 | } | ||
5072 | *x = p->s->img_x; | ||
5073 | *y = p->s->img_y; | ||
5074 | if (n) *n = p->s->img_n; | ||
5075 | } | ||
5076 | STBI_FREE(p->out); p->out = NULL; | ||
5077 | STBI_FREE(p->expanded); p->expanded = NULL; | ||
5078 | STBI_FREE(p->idata); p->idata = NULL; | ||
5079 | |||
5080 | return result; | ||
5081 | } | ||
5082 | |||
5083 | static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) | ||
5084 | { | ||
5085 | stbi__png p; | ||
5086 | p.s = s; | ||
5087 | return stbi__do_png(&p, x,y,comp,req_comp, ri); | ||
5088 | } | ||
5089 | |||
5090 | static int stbi__png_test(stbi__context *s) | ||
5091 | { | ||
5092 | int r; | ||
5093 | r = stbi__check_png_header(s); | ||
5094 | stbi__rewind(s); | ||
5095 | return r; | ||
5096 | } | ||
5097 | |||
5098 | static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp) | ||
5099 | { | ||
5100 | if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) { | ||
5101 | stbi__rewind( p->s ); | ||
5102 | return 0; | ||
5103 | } | ||
5104 | if (x) *x = p->s->img_x; | ||
5105 | if (y) *y = p->s->img_y; | ||
5106 | if (comp) *comp = p->s->img_n; | ||
5107 | return 1; | ||
5108 | } | ||
5109 | |||
5110 | static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp) | ||
5111 | { | ||
5112 | stbi__png p; | ||
5113 | p.s = s; | ||
5114 | return stbi__png_info_raw(&p, x, y, comp); | ||
5115 | } | ||
5116 | |||
5117 | static int stbi__png_is16(stbi__context *s) | ||
5118 | { | ||
5119 | stbi__png p; | ||
5120 | p.s = s; | ||
5121 | if (!stbi__png_info_raw(&p, NULL, NULL, NULL)) | ||
5122 | return 0; | ||
5123 | if (p.depth != 16) { | ||
5124 | stbi__rewind(p.s); | ||
5125 | return 0; | ||
5126 | } | ||
5127 | return 1; | ||
5128 | } | ||
5129 | #endif | ||
5130 | |||
5131 | // Microsoft/Windows BMP image | ||
5132 | |||
5133 | #ifndef STBI_NO_BMP | ||
5134 | static int stbi__bmp_test_raw(stbi__context *s) | ||
5135 | { | ||
5136 | int r; | ||
5137 | int sz; | ||
5138 | if (stbi__get8(s) != 'B') return 0; | ||
5139 | if (stbi__get8(s) != 'M') return 0; | ||
5140 | stbi__get32le(s); // discard filesize | ||
5141 | stbi__get16le(s); // discard reserved | ||
5142 | stbi__get16le(s); // discard reserved | ||
5143 | stbi__get32le(s); // discard data offset | ||
5144 | sz = stbi__get32le(s); | ||
5145 | r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124); | ||
5146 | return r; | ||
5147 | } | ||
5148 | |||
5149 | static int stbi__bmp_test(stbi__context *s) | ||
5150 | { | ||
5151 | int r = stbi__bmp_test_raw(s); | ||
5152 | stbi__rewind(s); | ||
5153 | return r; | ||
5154 | } | ||
5155 | |||
5156 | |||
5157 | // returns 0..31 for the highest set bit | ||
5158 | static int stbi__high_bit(unsigned int z) | ||
5159 | { | ||
5160 | int n=0; | ||
5161 | if (z == 0) return -1; | ||
5162 | if (z >= 0x10000) { n += 16; z >>= 16; } | ||
5163 | if (z >= 0x00100) { n += 8; z >>= 8; } | ||
5164 | if (z >= 0x00010) { n += 4; z >>= 4; } | ||
5165 | if (z >= 0x00004) { n += 2; z >>= 2; } | ||
5166 | if (z >= 0x00002) { n += 1;/* >>= 1;*/ } | ||
5167 | return n; | ||
5168 | } | ||
5169 | |||
5170 | static int stbi__bitcount(unsigned int a) | ||
5171 | { | ||
5172 | a = (a & 0x55555555) + ((a >> 1) & 0x55555555); // max 2 | ||
5173 | a = (a & 0x33333333) + ((a >> 2) & 0x33333333); // max 4 | ||
5174 | a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits | ||
5175 | a = (a + (a >> 8)); // max 16 per 8 bits | ||
5176 | a = (a + (a >> 16)); // max 32 per 8 bits | ||
5177 | return a & 0xff; | ||
5178 | } | ||
5179 | |||
5180 | // extract an arbitrarily-aligned N-bit value (N=bits) | ||
5181 | // from v, and then make it 8-bits long and fractionally | ||
5182 | // extend it to full full range. | ||
5183 | static int stbi__shiftsigned(unsigned int v, int shift, int bits) | ||
5184 | { | ||
5185 | static unsigned int mul_table[9] = { | ||
5186 | 0, | ||
5187 | 0xff/*0b11111111*/, 0x55/*0b01010101*/, 0x49/*0b01001001*/, 0x11/*0b00010001*/, | ||
5188 | 0x21/*0b00100001*/, 0x41/*0b01000001*/, 0x81/*0b10000001*/, 0x01/*0b00000001*/, | ||
5189 | }; | ||
5190 | static unsigned int shift_table[9] = { | ||
5191 | 0, 0,0,1,0,2,4,6,0, | ||
5192 | }; | ||
5193 | if (shift < 0) | ||
5194 | v <<= -shift; | ||
5195 | else | ||
5196 | v >>= shift; | ||
5197 | STBI_ASSERT(v < 256); | ||
5198 | v >>= (8-bits); | ||
5199 | STBI_ASSERT(bits >= 0 && bits <= 8); | ||
5200 | return (int) ((unsigned) v * mul_table[bits]) >> shift_table[bits]; | ||
5201 | } | ||
5202 | |||
5203 | typedef struct | ||
5204 | { | ||
5205 | int bpp, offset, hsz; | ||
5206 | unsigned int mr,mg,mb,ma, all_a; | ||
5207 | int extra_read; | ||
5208 | } stbi__bmp_data; | ||
5209 | |||
5210 | static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info) | ||
5211 | { | ||
5212 | int hsz; | ||
5213 | if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') return stbi__errpuc("not BMP", "Corrupt BMP"); | ||
5214 | stbi__get32le(s); // discard filesize | ||
5215 | stbi__get16le(s); // discard reserved | ||
5216 | stbi__get16le(s); // discard reserved | ||
5217 | info->offset = stbi__get32le(s); | ||
5218 | info->hsz = hsz = stbi__get32le(s); | ||
5219 | info->mr = info->mg = info->mb = info->ma = 0; | ||
5220 | info->extra_read = 14; | ||
5221 | |||
5222 | if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) return stbi__errpuc("unknown BMP", "BMP type not supported: unknown"); | ||
5223 | if (hsz == 12) { | ||
5224 | s->img_x = stbi__get16le(s); | ||
5225 | s->img_y = stbi__get16le(s); | ||
5226 | } else { | ||
5227 | s->img_x = stbi__get32le(s); | ||
5228 | s->img_y = stbi__get32le(s); | ||
5229 | } | ||
5230 | if (stbi__get16le(s) != 1) return stbi__errpuc("bad BMP", "bad BMP"); | ||
5231 | info->bpp = stbi__get16le(s); | ||
5232 | if (hsz != 12) { | ||
5233 | int compress = stbi__get32le(s); | ||
5234 | if (compress == 1 || compress == 2) return stbi__errpuc("BMP RLE", "BMP type not supported: RLE"); | ||
5235 | stbi__get32le(s); // discard sizeof | ||
5236 | stbi__get32le(s); // discard hres | ||
5237 | stbi__get32le(s); // discard vres | ||
5238 | stbi__get32le(s); // discard colorsused | ||
5239 | stbi__get32le(s); // discard max important | ||
5240 | if (hsz == 40 || hsz == 56) { | ||
5241 | if (hsz == 56) { | ||
5242 | stbi__get32le(s); | ||
5243 | stbi__get32le(s); | ||
5244 | stbi__get32le(s); | ||
5245 | stbi__get32le(s); | ||
5246 | } | ||
5247 | if (info->bpp == 16 || info->bpp == 32) { | ||
5248 | if (compress == 0) { | ||
5249 | if (info->bpp == 32) { | ||
5250 | info->mr = 0xffu << 16; | ||
5251 | info->mg = 0xffu << 8; | ||
5252 | info->mb = 0xffu << 0; | ||
5253 | info->ma = 0xffu << 24; | ||
5254 | info->all_a = 0; // if all_a is 0 at end, then we loaded alpha channel but it was all 0 | ||
5255 | } else { | ||
5256 | info->mr = 31u << 10; | ||
5257 | info->mg = 31u << 5; | ||
5258 | info->mb = 31u << 0; | ||
5259 | } | ||
5260 | } else if (compress == 3) { | ||
5261 | info->mr = stbi__get32le(s); | ||
5262 | info->mg = stbi__get32le(s); | ||
5263 | info->mb = stbi__get32le(s); | ||
5264 | info->extra_read += 12; | ||
5265 | // not documented, but generated by photoshop and handled by mspaint | ||
5266 | if (info->mr == info->mg && info->mg == info->mb) { | ||
5267 | // ?!?!? | ||
5268 | return stbi__errpuc("bad BMP", "bad BMP"); | ||
5269 | } | ||
5270 | } else | ||
5271 | return stbi__errpuc("bad BMP", "bad BMP"); | ||
5272 | } | ||
5273 | } else { | ||
5274 | int i; | ||
5275 | if (hsz != 108 && hsz != 124) | ||
5276 | return stbi__errpuc("bad BMP", "bad BMP"); | ||
5277 | info->mr = stbi__get32le(s); | ||
5278 | info->mg = stbi__get32le(s); | ||
5279 | info->mb = stbi__get32le(s); | ||
5280 | info->ma = stbi__get32le(s); | ||
5281 | stbi__get32le(s); // discard color space | ||
5282 | for (i=0; i < 12; ++i) | ||
5283 | stbi__get32le(s); // discard color space parameters | ||
5284 | if (hsz == 124) { | ||
5285 | stbi__get32le(s); // discard rendering intent | ||
5286 | stbi__get32le(s); // discard offset of profile data | ||
5287 | stbi__get32le(s); // discard size of profile data | ||
5288 | stbi__get32le(s); // discard reserved | ||
5289 | } | ||
5290 | } | ||
5291 | } | ||
5292 | return (void *) 1; | ||
5293 | } | ||
5294 | |||
5295 | |||
5296 | static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) | ||
5297 | { | ||
5298 | stbi_uc *out; | ||
5299 | unsigned int mr=0,mg=0,mb=0,ma=0, all_a; | ||
5300 | stbi_uc pal[256][4]; | ||
5301 | int psize=0,i,j,width; | ||
5302 | int flip_vertically, pad, target; | ||
5303 | stbi__bmp_data info; | ||
5304 | STBI_NOTUSED(ri); | ||
5305 | |||
5306 | info.all_a = 255; | ||
5307 | if (stbi__bmp_parse_header(s, &info) == NULL) | ||
5308 | return NULL; // error code already set | ||
5309 | |||
5310 | flip_vertically = ((int) s->img_y) > 0; | ||
5311 | s->img_y = abs((int) s->img_y); | ||
5312 | |||
5313 | mr = info.mr; | ||
5314 | mg = info.mg; | ||
5315 | mb = info.mb; | ||
5316 | ma = info.ma; | ||
5317 | all_a = info.all_a; | ||
5318 | |||
5319 | if (info.hsz == 12) { | ||
5320 | if (info.bpp < 24) | ||
5321 | psize = (info.offset - info.extra_read - 24) / 3; | ||
5322 | } else { | ||
5323 | if (info.bpp < 16) | ||
5324 | psize = (info.offset - info.extra_read - info.hsz) >> 2; | ||
5325 | } | ||
5326 | if (psize == 0) { | ||
5327 | STBI_ASSERT(info.offset == (s->img_buffer - s->buffer_start)); | ||
5328 | } | ||
5329 | |||
5330 | if (info.bpp == 24 && ma == 0xff000000) | ||
5331 | s->img_n = 3; | ||
5332 | else | ||
5333 | s->img_n = ma ? 4 : 3; | ||
5334 | if (req_comp && req_comp >= 3) // we can directly decode 3 or 4 | ||
5335 | target = req_comp; | ||
5336 | else | ||
5337 | target = s->img_n; // if they want monochrome, we'll post-convert | ||
5338 | |||
5339 | // sanity-check size | ||
5340 | if (!stbi__mad3sizes_valid(target, s->img_x, s->img_y, 0)) | ||
5341 | return stbi__errpuc("too large", "Corrupt BMP"); | ||
5342 | |||
5343 | out = (stbi_uc *) stbi__malloc_mad3(target, s->img_x, s->img_y, 0); | ||
5344 | if (!out) return stbi__errpuc("outofmem", "Out of memory"); | ||
5345 | if (info.bpp < 16) { | ||
5346 | int z=0; | ||
5347 | if (psize == 0 || psize > 256) { STBI_FREE(out); return stbi__errpuc("invalid", "Corrupt BMP"); } | ||
5348 | for (i=0; i < psize; ++i) { | ||
5349 | pal[i][2] = stbi__get8(s); | ||
5350 | pal[i][1] = stbi__get8(s); | ||
5351 | pal[i][0] = stbi__get8(s); | ||
5352 | if (info.hsz != 12) stbi__get8(s); | ||
5353 | pal[i][3] = 255; | ||
5354 | } | ||
5355 | stbi__skip(s, info.offset - info.extra_read - info.hsz - psize * (info.hsz == 12 ? 3 : 4)); | ||
5356 | if (info.bpp == 1) width = (s->img_x + 7) >> 3; | ||
5357 | else if (info.bpp == 4) width = (s->img_x + 1) >> 1; | ||
5358 | else if (info.bpp == 8) width = s->img_x; | ||
5359 | else { STBI_FREE(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); } | ||
5360 | pad = (-width)&3; | ||
5361 | if (info.bpp == 1) { | ||
5362 | for (j=0; j < (int) s->img_y; ++j) { | ||
5363 | int bit_offset = 7, v = stbi__get8(s); | ||
5364 | for (i=0; i < (int) s->img_x; ++i) { | ||
5365 | int color = (v>>bit_offset)&0x1; | ||
5366 | out[z++] = pal[color][0]; | ||
5367 | out[z++] = pal[color][1]; | ||
5368 | out[z++] = pal[color][2]; | ||
5369 | if (target == 4) out[z++] = 255; | ||
5370 | if (i+1 == (int) s->img_x) break; | ||
5371 | if((--bit_offset) < 0) { | ||
5372 | bit_offset = 7; | ||
5373 | v = stbi__get8(s); | ||
5374 | } | ||
5375 | } | ||
5376 | stbi__skip(s, pad); | ||
5377 | } | ||
5378 | } else { | ||
5379 | for (j=0; j < (int) s->img_y; ++j) { | ||
5380 | for (i=0; i < (int) s->img_x; i += 2) { | ||
5381 | int v=stbi__get8(s),v2=0; | ||
5382 | if (info.bpp == 4) { | ||
5383 | v2 = v & 15; | ||
5384 | v >>= 4; | ||
5385 | } | ||
5386 | out[z++] = pal[v][0]; | ||
5387 | out[z++] = pal[v][1]; | ||
5388 | out[z++] = pal[v][2]; | ||
5389 | if (target == 4) out[z++] = 255; | ||
5390 | if (i+1 == (int) s->img_x) break; | ||
5391 | v = (info.bpp == 8) ? stbi__get8(s) : v2; | ||
5392 | out[z++] = pal[v][0]; | ||
5393 | out[z++] = pal[v][1]; | ||
5394 | out[z++] = pal[v][2]; | ||
5395 | if (target == 4) out[z++] = 255; | ||
5396 | } | ||
5397 | stbi__skip(s, pad); | ||
5398 | } | ||
5399 | } | ||
5400 | } else { | ||
5401 | int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0; | ||
5402 | int z = 0; | ||
5403 | int easy=0; | ||
5404 | stbi__skip(s, info.offset - info.extra_read - info.hsz); | ||
5405 | if (info.bpp == 24) width = 3 * s->img_x; | ||
5406 | else if (info.bpp == 16) width = 2*s->img_x; | ||
5407 | else /* bpp = 32 and pad = 0 */ width=0; | ||
5408 | pad = (-width) & 3; | ||
5409 | if (info.bpp == 24) { | ||
5410 | easy = 1; | ||
5411 | } else if (info.bpp == 32) { | ||
5412 | if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000) | ||
5413 | easy = 2; | ||
5414 | } | ||
5415 | if (!easy) { | ||
5416 | if (!mr || !mg || !mb) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } | ||
5417 | // right shift amt to put high bit in position #7 | ||
5418 | rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr); | ||
5419 | gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg); | ||
5420 | bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb); | ||
5421 | ashift = stbi__high_bit(ma)-7; acount = stbi__bitcount(ma); | ||
5422 | } | ||
5423 | for (j=0; j < (int) s->img_y; ++j) { | ||
5424 | if (easy) { | ||
5425 | for (i=0; i < (int) s->img_x; ++i) { | ||
5426 | unsigned char a; | ||
5427 | out[z+2] = stbi__get8(s); | ||
5428 | out[z+1] = stbi__get8(s); | ||
5429 | out[z+0] = stbi__get8(s); | ||
5430 | z += 3; | ||
5431 | a = (easy == 2 ? stbi__get8(s) : 255); | ||
5432 | all_a |= a; | ||
5433 | if (target == 4) out[z++] = a; | ||
5434 | } | ||
5435 | } else { | ||
5436 | int bpp = info.bpp; | ||
5437 | for (i=0; i < (int) s->img_x; ++i) { | ||
5438 | stbi__uint32 v = (bpp == 16 ? (stbi__uint32) stbi__get16le(s) : stbi__get32le(s)); | ||
5439 | unsigned int a; | ||
5440 | out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount)); | ||
5441 | out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount)); | ||
5442 | out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount)); | ||
5443 | a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255); | ||
5444 | all_a |= a; | ||
5445 | if (target == 4) out[z++] = STBI__BYTECAST(a); | ||
5446 | } | ||
5447 | } | ||
5448 | stbi__skip(s, pad); | ||
5449 | } | ||
5450 | } | ||
5451 | |||
5452 | // if alpha channel is all 0s, replace with all 255s | ||
5453 | if (target == 4 && all_a == 0) | ||
5454 | for (i=4*s->img_x*s->img_y-1; i >= 0; i -= 4) | ||
5455 | out[i] = 255; | ||
5456 | |||
5457 | if (flip_vertically) { | ||
5458 | stbi_uc t; | ||
5459 | for (j=0; j < (int) s->img_y>>1; ++j) { | ||
5460 | stbi_uc *p1 = out + j *s->img_x*target; | ||
5461 | stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target; | ||
5462 | for (i=0; i < (int) s->img_x*target; ++i) { | ||
5463 | t = p1[i]; p1[i] = p2[i]; p2[i] = t; | ||
5464 | } | ||
5465 | } | ||
5466 | } | ||
5467 | |||
5468 | if (req_comp && req_comp != target) { | ||
5469 | out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y); | ||
5470 | if (out == NULL) return out; // stbi__convert_format frees input on failure | ||
5471 | } | ||
5472 | |||
5473 | *x = s->img_x; | ||
5474 | *y = s->img_y; | ||
5475 | if (comp) *comp = s->img_n; | ||
5476 | return out; | ||
5477 | } | ||
5478 | #endif | ||
5479 | |||
5480 | // Targa Truevision - TGA | ||
5481 | // by Jonathan Dummer | ||
5482 | #ifndef STBI_NO_TGA | ||
5483 | // returns STBI_rgb or whatever, 0 on error | ||
5484 | static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16) | ||
5485 | { | ||
5486 | // only RGB or RGBA (incl. 16bit) or grey allowed | ||
5487 | if (is_rgb16) *is_rgb16 = 0; | ||
5488 | switch(bits_per_pixel) { | ||
5489 | case 8: return STBI_grey; | ||
5490 | case 16: if(is_grey) return STBI_grey_alpha; | ||
5491 | // fallthrough | ||
5492 | case 15: if(is_rgb16) *is_rgb16 = 1; | ||
5493 | return STBI_rgb; | ||
5494 | case 24: // fallthrough | ||
5495 | case 32: return bits_per_pixel/8; | ||
5496 | default: return 0; | ||
5497 | } | ||
5498 | } | ||
5499 | |||
5500 | static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp) | ||
5501 | { | ||
5502 | int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp; | ||
5503 | int sz, tga_colormap_type; | ||
5504 | stbi__get8(s); // discard Offset | ||
5505 | tga_colormap_type = stbi__get8(s); // colormap type | ||
5506 | if( tga_colormap_type > 1 ) { | ||
5507 | stbi__rewind(s); | ||
5508 | return 0; // only RGB or indexed allowed | ||
5509 | } | ||
5510 | tga_image_type = stbi__get8(s); // image type | ||
5511 | if ( tga_colormap_type == 1 ) { // colormapped (paletted) image | ||
5512 | if (tga_image_type != 1 && tga_image_type != 9) { | ||
5513 | stbi__rewind(s); | ||
5514 | return 0; | ||
5515 | } | ||
5516 | stbi__skip(s,4); // skip index of first colormap entry and number of entries | ||
5517 | sz = stbi__get8(s); // check bits per palette color entry | ||
5518 | if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) { | ||
5519 | stbi__rewind(s); | ||
5520 | return 0; | ||
5521 | } | ||
5522 | stbi__skip(s,4); // skip image x and y origin | ||
5523 | tga_colormap_bpp = sz; | ||
5524 | } else { // "normal" image w/o colormap - only RGB or grey allowed, +/- RLE | ||
5525 | if ( (tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) && (tga_image_type != 11) ) { | ||
5526 | stbi__rewind(s); | ||
5527 | return 0; // only RGB or grey allowed, +/- RLE | ||
5528 | } | ||
5529 | stbi__skip(s,9); // skip colormap specification and image x/y origin | ||
5530 | tga_colormap_bpp = 0; | ||
5531 | } | ||
5532 | tga_w = stbi__get16le(s); | ||
5533 | if( tga_w < 1 ) { | ||
5534 | stbi__rewind(s); | ||
5535 | return 0; // test width | ||
5536 | } | ||
5537 | tga_h = stbi__get16le(s); | ||
5538 | if( tga_h < 1 ) { | ||
5539 | stbi__rewind(s); | ||
5540 | return 0; // test height | ||
5541 | } | ||
5542 | tga_bits_per_pixel = stbi__get8(s); // bits per pixel | ||
5543 | stbi__get8(s); // ignore alpha bits | ||
5544 | if (tga_colormap_bpp != 0) { | ||
5545 | if((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16)) { | ||
5546 | // when using a colormap, tga_bits_per_pixel is the size of the indexes | ||
5547 | // I don't think anything but 8 or 16bit indexes makes sense | ||
5548 | stbi__rewind(s); | ||
5549 | return 0; | ||
5550 | } | ||
5551 | tga_comp = stbi__tga_get_comp(tga_colormap_bpp, 0, NULL); | ||
5552 | } else { | ||
5553 | tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3) || (tga_image_type == 11), NULL); | ||
5554 | } | ||
5555 | if(!tga_comp) { | ||
5556 | stbi__rewind(s); | ||
5557 | return 0; | ||
5558 | } | ||
5559 | if (x) *x = tga_w; | ||
5560 | if (y) *y = tga_h; | ||
5561 | if (comp) *comp = tga_comp; | ||
5562 | return 1; // seems to have passed everything | ||
5563 | } | ||
5564 | |||
5565 | static int stbi__tga_test(stbi__context *s) | ||
5566 | { | ||
5567 | int res = 0; | ||
5568 | int sz, tga_color_type; | ||
5569 | stbi__get8(s); // discard Offset | ||
5570 | tga_color_type = stbi__get8(s); // color type | ||
5571 | if ( tga_color_type > 1 ) goto errorEnd; // only RGB or indexed allowed | ||
5572 | sz = stbi__get8(s); // image type | ||
5573 | if ( tga_color_type == 1 ) { // colormapped (paletted) image | ||
5574 | if (sz != 1 && sz != 9) goto errorEnd; // colortype 1 demands image type 1 or 9 | ||
5575 | stbi__skip(s,4); // skip index of first colormap entry and number of entries | ||
5576 | sz = stbi__get8(s); // check bits per palette color entry | ||
5577 | if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd; | ||
5578 | stbi__skip(s,4); // skip image x and y origin | ||
5579 | } else { // "normal" image w/o colormap | ||
5580 | if ( (sz != 2) && (sz != 3) && (sz != 10) && (sz != 11) ) goto errorEnd; // only RGB or grey allowed, +/- RLE | ||
5581 | stbi__skip(s,9); // skip colormap specification and image x/y origin | ||
5582 | } | ||
5583 | if ( stbi__get16le(s) < 1 ) goto errorEnd; // test width | ||
5584 | if ( stbi__get16le(s) < 1 ) goto errorEnd; // test height | ||
5585 | sz = stbi__get8(s); // bits per pixel | ||
5586 | if ( (tga_color_type == 1) && (sz != 8) && (sz != 16) ) goto errorEnd; // for colormapped images, bpp is size of an index | ||
5587 | if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd; | ||
5588 | |||
5589 | res = 1; // if we got this far, everything's good and we can return 1 instead of 0 | ||
5590 | |||
5591 | errorEnd: | ||
5592 | stbi__rewind(s); | ||
5593 | return res; | ||
5594 | } | ||
5595 | |||
5596 | // read 16bit value and convert to 24bit RGB | ||
5597 | static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out) | ||
5598 | { | ||
5599 | stbi__uint16 px = (stbi__uint16)stbi__get16le(s); | ||
5600 | stbi__uint16 fiveBitMask = 31; | ||
5601 | // we have 3 channels with 5bits each | ||
5602 | int r = (px >> 10) & fiveBitMask; | ||
5603 | int g = (px >> 5) & fiveBitMask; | ||
5604 | int b = px & fiveBitMask; | ||
5605 | // Note that this saves the data in RGB(A) order, so it doesn't need to be swapped later | ||
5606 | out[0] = (stbi_uc)((r * 255)/31); | ||
5607 | out[1] = (stbi_uc)((g * 255)/31); | ||
5608 | out[2] = (stbi_uc)((b * 255)/31); | ||
5609 | |||
5610 | // some people claim that the most significant bit might be used for alpha | ||
5611 | // (possibly if an alpha-bit is set in the "image descriptor byte") | ||
5612 | // but that only made 16bit test images completely translucent.. | ||
5613 | // so let's treat all 15 and 16bit TGAs as RGB with no alpha. | ||
5614 | } | ||
5615 | |||
5616 | static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) | ||
5617 | { | ||
5618 | // read in the TGA header stuff | ||
5619 | int tga_offset = stbi__get8(s); | ||
5620 | int tga_indexed = stbi__get8(s); | ||
5621 | int tga_image_type = stbi__get8(s); | ||
5622 | int tga_is_RLE = 0; | ||
5623 | int tga_palette_start = stbi__get16le(s); | ||
5624 | int tga_palette_len = stbi__get16le(s); | ||
5625 | int tga_palette_bits = stbi__get8(s); | ||
5626 | int tga_x_origin = stbi__get16le(s); | ||
5627 | int tga_y_origin = stbi__get16le(s); | ||
5628 | int tga_width = stbi__get16le(s); | ||
5629 | int tga_height = stbi__get16le(s); | ||
5630 | int tga_bits_per_pixel = stbi__get8(s); | ||
5631 | int tga_comp, tga_rgb16=0; | ||
5632 | int tga_inverted = stbi__get8(s); | ||
5633 | // int tga_alpha_bits = tga_inverted & 15; // the 4 lowest bits - unused (useless?) | ||
5634 | // image data | ||
5635 | unsigned char *tga_data; | ||
5636 | unsigned char *tga_palette = NULL; | ||
5637 | int i, j; | ||
5638 | unsigned char raw_data[4] = {0}; | ||
5639 | int RLE_count = 0; | ||
5640 | int RLE_repeating = 0; | ||
5641 | int read_next_pixel = 1; | ||
5642 | STBI_NOTUSED(ri); | ||
5643 | STBI_NOTUSED(tga_x_origin); // @TODO | ||
5644 | STBI_NOTUSED(tga_y_origin); // @TODO | ||
5645 | |||
5646 | // do a tiny bit of precessing | ||
5647 | if ( tga_image_type >= 8 ) | ||
5648 | { | ||
5649 | tga_image_type -= 8; | ||
5650 | tga_is_RLE = 1; | ||
5651 | } | ||
5652 | tga_inverted = 1 - ((tga_inverted >> 5) & 1); | ||
5653 | |||
5654 | // If I'm paletted, then I'll use the number of bits from the palette | ||
5655 | if ( tga_indexed ) tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16); | ||
5656 | else tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16); | ||
5657 | |||
5658 | if(!tga_comp) // shouldn't really happen, stbi__tga_test() should have ensured basic consistency | ||
5659 | return stbi__errpuc("bad format", "Can't find out TGA pixelformat"); | ||
5660 | |||
5661 | // tga info | ||
5662 | *x = tga_width; | ||
5663 | *y = tga_height; | ||
5664 | if (comp) *comp = tga_comp; | ||
5665 | |||
5666 | if (!stbi__mad3sizes_valid(tga_width, tga_height, tga_comp, 0)) | ||
5667 | return stbi__errpuc("too large", "Corrupt TGA"); | ||
5668 | |||
5669 | tga_data = (unsigned char*)stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0); | ||
5670 | if (!tga_data) return stbi__errpuc("outofmem", "Out of memory"); | ||
5671 | |||
5672 | // skip to the data's starting position (offset usually = 0) | ||
5673 | stbi__skip(s, tga_offset ); | ||
5674 | |||
5675 | if ( !tga_indexed && !tga_is_RLE && !tga_rgb16 ) { | ||
5676 | for (i=0; i < tga_height; ++i) { | ||
5677 | int row = tga_inverted ? tga_height -i - 1 : i; | ||
5678 | stbi_uc *tga_row = tga_data + row*tga_width*tga_comp; | ||
5679 | stbi__getn(s, tga_row, tga_width * tga_comp); | ||
5680 | } | ||
5681 | } else { | ||
5682 | // do I need to load a palette? | ||
5683 | if ( tga_indexed) | ||
5684 | { | ||
5685 | // any data to skip? (offset usually = 0) | ||
5686 | stbi__skip(s, tga_palette_start ); | ||
5687 | // load the palette | ||
5688 | tga_palette = (unsigned char*)stbi__malloc_mad2(tga_palette_len, tga_comp, 0); | ||
5689 | if (!tga_palette) { | ||
5690 | STBI_FREE(tga_data); | ||
5691 | return stbi__errpuc("outofmem", "Out of memory"); | ||
5692 | } | ||
5693 | if (tga_rgb16) { | ||
5694 | stbi_uc *pal_entry = tga_palette; | ||
5695 | STBI_ASSERT(tga_comp == STBI_rgb); | ||
5696 | for (i=0; i < tga_palette_len; ++i) { | ||
5697 | stbi__tga_read_rgb16(s, pal_entry); | ||
5698 | pal_entry += tga_comp; | ||
5699 | } | ||
5700 | } else if (!stbi__getn(s, tga_palette, tga_palette_len * tga_comp)) { | ||
5701 | STBI_FREE(tga_data); | ||
5702 | STBI_FREE(tga_palette); | ||
5703 | return stbi__errpuc("bad palette", "Corrupt TGA"); | ||
5704 | } | ||
5705 | } | ||
5706 | // load the data | ||
5707 | for (i=0; i < tga_width * tga_height; ++i) | ||
5708 | { | ||
5709 | // if I'm in RLE mode, do I need to get a RLE stbi__pngchunk? | ||
5710 | if ( tga_is_RLE ) | ||
5711 | { | ||
5712 | if ( RLE_count == 0 ) | ||
5713 | { | ||
5714 | // yep, get the next byte as a RLE command | ||
5715 | int RLE_cmd = stbi__get8(s); | ||
5716 | RLE_count = 1 + (RLE_cmd & 127); | ||
5717 | RLE_repeating = RLE_cmd >> 7; | ||
5718 | read_next_pixel = 1; | ||
5719 | } else if ( !RLE_repeating ) | ||
5720 | { | ||
5721 | read_next_pixel = 1; | ||
5722 | } | ||
5723 | } else | ||
5724 | { | ||
5725 | read_next_pixel = 1; | ||
5726 | } | ||
5727 | // OK, if I need to read a pixel, do it now | ||
5728 | if ( read_next_pixel ) | ||
5729 | { | ||
5730 | // load however much data we did have | ||
5731 | if ( tga_indexed ) | ||
5732 | { | ||
5733 | // read in index, then perform the lookup | ||
5734 | int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s); | ||
5735 | if ( pal_idx >= tga_palette_len ) { | ||
5736 | // invalid index | ||
5737 | pal_idx = 0; | ||
5738 | } | ||
5739 | pal_idx *= tga_comp; | ||
5740 | for (j = 0; j < tga_comp; ++j) { | ||
5741 | raw_data[j] = tga_palette[pal_idx+j]; | ||
5742 | } | ||
5743 | } else if(tga_rgb16) { | ||
5744 | STBI_ASSERT(tga_comp == STBI_rgb); | ||
5745 | stbi__tga_read_rgb16(s, raw_data); | ||
5746 | } else { | ||
5747 | // read in the data raw | ||
5748 | for (j = 0; j < tga_comp; ++j) { | ||
5749 | raw_data[j] = stbi__get8(s); | ||
5750 | } | ||
5751 | } | ||
5752 | // clear the reading flag for the next pixel | ||
5753 | read_next_pixel = 0; | ||
5754 | } // end of reading a pixel | ||
5755 | |||
5756 | // copy data | ||
5757 | for (j = 0; j < tga_comp; ++j) | ||
5758 | tga_data[i*tga_comp+j] = raw_data[j]; | ||
5759 | |||
5760 | // in case we're in RLE mode, keep counting down | ||
5761 | --RLE_count; | ||
5762 | } | ||
5763 | // do I need to invert the image? | ||
5764 | if ( tga_inverted ) | ||
5765 | { | ||
5766 | for (j = 0; j*2 < tga_height; ++j) | ||
5767 | { | ||
5768 | int index1 = j * tga_width * tga_comp; | ||
5769 | int index2 = (tga_height - 1 - j) * tga_width * tga_comp; | ||
5770 | for (i = tga_width * tga_comp; i > 0; --i) | ||
5771 | { | ||
5772 | unsigned char temp = tga_data[index1]; | ||
5773 | tga_data[index1] = tga_data[index2]; | ||
5774 | tga_data[index2] = temp; | ||
5775 | ++index1; | ||
5776 | ++index2; | ||
5777 | } | ||
5778 | } | ||
5779 | } | ||
5780 | // clear my palette, if I had one | ||
5781 | if ( tga_palette != NULL ) | ||
5782 | { | ||
5783 | STBI_FREE( tga_palette ); | ||
5784 | } | ||
5785 | } | ||
5786 | |||
5787 | // swap RGB - if the source data was RGB16, it already is in the right order | ||
5788 | if (tga_comp >= 3 && !tga_rgb16) | ||
5789 | { | ||
5790 | unsigned char* tga_pixel = tga_data; | ||
5791 | for (i=0; i < tga_width * tga_height; ++i) | ||
5792 | { | ||
5793 | unsigned char temp = tga_pixel[0]; | ||
5794 | tga_pixel[0] = tga_pixel[2]; | ||
5795 | tga_pixel[2] = temp; | ||
5796 | tga_pixel += tga_comp; | ||
5797 | } | ||
5798 | } | ||
5799 | |||
5800 | // convert to target component count | ||
5801 | if (req_comp && req_comp != tga_comp) | ||
5802 | tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height); | ||
5803 | |||
5804 | // the things I do to get rid of an error message, and yet keep | ||
5805 | // Microsoft's C compilers happy... [8^( | ||
5806 | tga_palette_start = tga_palette_len = tga_palette_bits = | ||
5807 | tga_x_origin = tga_y_origin = 0; | ||
5808 | STBI_NOTUSED(tga_palette_start); | ||
5809 | // OK, done | ||
5810 | return tga_data; | ||
5811 | } | ||
5812 | #endif | ||
5813 | |||
5814 | // ************************************************************************************************* | ||
5815 | // Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB | ||
5816 | |||
5817 | #ifndef STBI_NO_PSD | ||
5818 | static int stbi__psd_test(stbi__context *s) | ||
5819 | { | ||
5820 | int r = (stbi__get32be(s) == 0x38425053); | ||
5821 | stbi__rewind(s); | ||
5822 | return r; | ||
5823 | } | ||
5824 | |||
5825 | static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount) | ||
5826 | { | ||
5827 | int count, nleft, len; | ||
5828 | |||
5829 | count = 0; | ||
5830 | while ((nleft = pixelCount - count) > 0) { | ||
5831 | len = stbi__get8(s); | ||
5832 | if (len == 128) { | ||
5833 | // No-op. | ||
5834 | } else if (len < 128) { | ||
5835 | // Copy next len+1 bytes literally. | ||
5836 | len++; | ||
5837 | if (len > nleft) return 0; // corrupt data | ||
5838 | count += len; | ||
5839 | while (len) { | ||
5840 | *p = stbi__get8(s); | ||
5841 | p += 4; | ||
5842 | len--; | ||
5843 | } | ||
5844 | } else if (len > 128) { | ||
5845 | stbi_uc val; | ||
5846 | // Next -len+1 bytes in the dest are replicated from next source byte. | ||
5847 | // (Interpret len as a negative 8-bit int.) | ||
5848 | len = 257 - len; | ||
5849 | if (len > nleft) return 0; // corrupt data | ||
5850 | val = stbi__get8(s); | ||
5851 | count += len; | ||
5852 | while (len) { | ||
5853 | *p = val; | ||
5854 | p += 4; | ||
5855 | len--; | ||
5856 | } | ||
5857 | } | ||
5858 | } | ||
5859 | |||
5860 | return 1; | ||
5861 | } | ||
5862 | |||
5863 | static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc) | ||
5864 | { | ||
5865 | int pixelCount; | ||
5866 | int channelCount, compression; | ||
5867 | int channel, i; | ||
5868 | int bitdepth; | ||
5869 | int w,h; | ||
5870 | stbi_uc *out; | ||
5871 | STBI_NOTUSED(ri); | ||
5872 | |||
5873 | // Check identifier | ||
5874 | if (stbi__get32be(s) != 0x38425053) // "8BPS" | ||
5875 | return stbi__errpuc("not PSD", "Corrupt PSD image"); | ||
5876 | |||
5877 | // Check file type version. | ||
5878 | if (stbi__get16be(s) != 1) | ||
5879 | return stbi__errpuc("wrong version", "Unsupported version of PSD image"); | ||
5880 | |||
5881 | // Skip 6 reserved bytes. | ||
5882 | stbi__skip(s, 6 ); | ||
5883 | |||
5884 | // Read the number of channels (R, G, B, A, etc). | ||
5885 | channelCount = stbi__get16be(s); | ||
5886 | if (channelCount < 0 || channelCount > 16) | ||
5887 | return stbi__errpuc("wrong channel count", "Unsupported number of channels in PSD image"); | ||
5888 | |||
5889 | // Read the rows and columns of the image. | ||
5890 | h = stbi__get32be(s); | ||
5891 | w = stbi__get32be(s); | ||
5892 | |||
5893 | // Make sure the depth is 8 bits. | ||
5894 | bitdepth = stbi__get16be(s); | ||
5895 | if (bitdepth != 8 && bitdepth != 16) | ||
5896 | return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 or 16 bit"); | ||
5897 | |||
5898 | // Make sure the color mode is RGB. | ||
5899 | // Valid options are: | ||
5900 | // 0: Bitmap | ||
5901 | // 1: Grayscale | ||
5902 | // 2: Indexed color | ||
5903 | // 3: RGB color | ||
5904 | // 4: CMYK color | ||
5905 | // 7: Multichannel | ||
5906 | // 8: Duotone | ||
5907 | // 9: Lab color | ||
5908 | if (stbi__get16be(s) != 3) | ||
5909 | return stbi__errpuc("wrong color format", "PSD is not in RGB color format"); | ||
5910 | |||
5911 | // Skip the Mode Data. (It's the palette for indexed color; other info for other modes.) | ||
5912 | stbi__skip(s,stbi__get32be(s) ); | ||
5913 | |||
5914 | // Skip the image resources. (resolution, pen tool paths, etc) | ||
5915 | stbi__skip(s, stbi__get32be(s) ); | ||
5916 | |||
5917 | // Skip the reserved data. | ||
5918 | stbi__skip(s, stbi__get32be(s) ); | ||
5919 | |||
5920 | // Find out if the data is compressed. | ||
5921 | // Known values: | ||
5922 | // 0: no compression | ||
5923 | // 1: RLE compressed | ||
5924 | compression = stbi__get16be(s); | ||
5925 | if (compression > 1) | ||
5926 | return stbi__errpuc("bad compression", "PSD has an unknown compression format"); | ||
5927 | |||
5928 | // Check size | ||
5929 | if (!stbi__mad3sizes_valid(4, w, h, 0)) | ||
5930 | return stbi__errpuc("too large", "Corrupt PSD"); | ||
5931 | |||
5932 | // Create the destination image. | ||
5933 | |||
5934 | if (!compression && bitdepth == 16 && bpc == 16) { | ||
5935 | out = (stbi_uc *) stbi__malloc_mad3(8, w, h, 0); | ||
5936 | ri->bits_per_channel = 16; | ||
5937 | } else | ||
5938 | out = (stbi_uc *) stbi__malloc(4 * w*h); | ||
5939 | |||
5940 | if (!out) return stbi__errpuc("outofmem", "Out of memory"); | ||
5941 | pixelCount = w*h; | ||
5942 | |||
5943 | // Initialize the data to zero. | ||
5944 | //memset( out, 0, pixelCount * 4 ); | ||
5945 | |||
5946 | // Finally, the image data. | ||
5947 | if (compression) { | ||
5948 | // RLE as used by .PSD and .TIFF | ||
5949 | // Loop until you get the number of unpacked bytes you are expecting: | ||
5950 | // Read the next source byte into n. | ||
5951 | // If n is between 0 and 127 inclusive, copy the next n+1 bytes literally. | ||
5952 | // Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times. | ||
5953 | // Else if n is 128, noop. | ||
5954 | // Endloop | ||
5955 | |||
5956 | // The RLE-compressed data is preceded by a 2-byte data count for each row in the data, | ||
5957 | // which we're going to just skip. | ||
5958 | stbi__skip(s, h * channelCount * 2 ); | ||
5959 | |||
5960 | // Read the RLE data by channel. | ||
5961 | for (channel = 0; channel < 4; channel++) { | ||
5962 | stbi_uc *p; | ||
5963 | |||
5964 | p = out+channel; | ||
5965 | if (channel >= channelCount) { | ||
5966 | // Fill this channel with default data. | ||
5967 | for (i = 0; i < pixelCount; i++, p += 4) | ||
5968 | *p = (channel == 3 ? 255 : 0); | ||
5969 | } else { | ||
5970 | // Read the RLE data. | ||
5971 | if (!stbi__psd_decode_rle(s, p, pixelCount)) { | ||
5972 | STBI_FREE(out); | ||
5973 | return stbi__errpuc("corrupt", "bad RLE data"); | ||
5974 | } | ||
5975 | } | ||
5976 | } | ||
5977 | |||
5978 | } else { | ||
5979 | // We're at the raw image data. It's each channel in order (Red, Green, Blue, Alpha, ...) | ||
5980 | // where each channel consists of an 8-bit (or 16-bit) value for each pixel in the image. | ||
5981 | |||
5982 | // Read the data by channel. | ||
5983 | for (channel = 0; channel < 4; channel++) { | ||
5984 | if (channel >= channelCount) { | ||
5985 | // Fill this channel with default data. | ||
5986 | if (bitdepth == 16 && bpc == 16) { | ||
5987 | stbi__uint16 *q = ((stbi__uint16 *) out) + channel; | ||
5988 | stbi__uint16 val = channel == 3 ? 65535 : 0; | ||
5989 | for (i = 0; i < pixelCount; i++, q += 4) | ||
5990 | *q = val; | ||
5991 | } else { | ||
5992 | stbi_uc *p = out+channel; | ||
5993 | stbi_uc val = channel == 3 ? 255 : 0; | ||
5994 | for (i = 0; i < pixelCount; i++, p += 4) | ||
5995 | *p = val; | ||
5996 | } | ||
5997 | } else { | ||
5998 | if (ri->bits_per_channel == 16) { // output bpc | ||
5999 | stbi__uint16 *q = ((stbi__uint16 *) out) + channel; | ||
6000 | for (i = 0; i < pixelCount; i++, q += 4) | ||
6001 | *q = (stbi__uint16) stbi__get16be(s); | ||
6002 | } else { | ||
6003 | stbi_uc *p = out+channel; | ||
6004 | if (bitdepth == 16) { // input bpc | ||
6005 | for (i = 0; i < pixelCount; i++, p += 4) | ||
6006 | *p = (stbi_uc) (stbi__get16be(s) >> 8); | ||
6007 | } else { | ||
6008 | for (i = 0; i < pixelCount; i++, p += 4) | ||
6009 | *p = stbi__get8(s); | ||
6010 | } | ||
6011 | } | ||
6012 | } | ||
6013 | } | ||
6014 | } | ||
6015 | |||
6016 | // remove weird white matte from PSD | ||
6017 | if (channelCount >= 4) { | ||
6018 | if (ri->bits_per_channel == 16) { | ||
6019 | for (i=0; i < w*h; ++i) { | ||
6020 | stbi__uint16 *pixel = (stbi__uint16 *) out + 4*i; | ||
6021 | if (pixel[3] != 0 && pixel[3] != 65535) { | ||
6022 | float a = pixel[3] / 65535.0f; | ||
6023 | float ra = 1.0f / a; | ||
6024 | float inv_a = 65535.0f * (1 - ra); | ||
6025 | pixel[0] = (stbi__uint16) (pixel[0]*ra + inv_a); | ||
6026 | pixel[1] = (stbi__uint16) (pixel[1]*ra + inv_a); | ||
6027 | pixel[2] = (stbi__uint16) (pixel[2]*ra + inv_a); | ||
6028 | } | ||
6029 | } | ||
6030 | } else { | ||
6031 | for (i=0; i < w*h; ++i) { | ||
6032 | unsigned char *pixel = out + 4*i; | ||
6033 | if (pixel[3] != 0 && pixel[3] != 255) { | ||
6034 | float a = pixel[3] / 255.0f; | ||
6035 | float ra = 1.0f / a; | ||
6036 | float inv_a = 255.0f * (1 - ra); | ||
6037 | pixel[0] = (unsigned char) (pixel[0]*ra + inv_a); | ||
6038 | pixel[1] = (unsigned char) (pixel[1]*ra + inv_a); | ||
6039 | pixel[2] = (unsigned char) (pixel[2]*ra + inv_a); | ||
6040 | } | ||
6041 | } | ||
6042 | } | ||
6043 | } | ||
6044 | |||
6045 | // convert to desired output format | ||
6046 | if (req_comp && req_comp != 4) { | ||
6047 | if (ri->bits_per_channel == 16) | ||
6048 | out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, 4, req_comp, w, h); | ||
6049 | else | ||
6050 | out = stbi__convert_format(out, 4, req_comp, w, h); | ||
6051 | if (out == NULL) return out; // stbi__convert_format frees input on failure | ||
6052 | } | ||
6053 | |||
6054 | if (comp) *comp = 4; | ||
6055 | *y = h; | ||
6056 | *x = w; | ||
6057 | |||
6058 | return out; | ||
6059 | } | ||
6060 | #endif | ||
6061 | |||
6062 | // ************************************************************************************************* | ||
6063 | // Softimage PIC loader | ||
6064 | // by Tom Seddon | ||
6065 | // | ||
6066 | // See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format | ||
6067 | // See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/ | ||
6068 | |||
6069 | #ifndef STBI_NO_PIC | ||
6070 | static int stbi__pic_is4(stbi__context *s,const char *str) | ||
6071 | { | ||
6072 | int i; | ||
6073 | for (i=0; i<4; ++i) | ||
6074 | if (stbi__get8(s) != (stbi_uc)str[i]) | ||
6075 | return 0; | ||
6076 | |||
6077 | return 1; | ||
6078 | } | ||
6079 | |||
6080 | static int stbi__pic_test_core(stbi__context *s) | ||
6081 | { | ||
6082 | int i; | ||
6083 | |||
6084 | if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) | ||
6085 | return 0; | ||
6086 | |||
6087 | for(i=0;i<84;++i) | ||
6088 | stbi__get8(s); | ||
6089 | |||
6090 | if (!stbi__pic_is4(s,"PICT")) | ||
6091 | return 0; | ||
6092 | |||
6093 | return 1; | ||
6094 | } | ||
6095 | |||
6096 | typedef struct | ||
6097 | { | ||
6098 | stbi_uc size,type,channel; | ||
6099 | } stbi__pic_packet; | ||
6100 | |||
6101 | static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest) | ||
6102 | { | ||
6103 | int mask=0x80, i; | ||
6104 | |||
6105 | for (i=0; i<4; ++i, mask>>=1) { | ||
6106 | if (channel & mask) { | ||
6107 | if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short"); | ||
6108 | dest[i]=stbi__get8(s); | ||
6109 | } | ||
6110 | } | ||
6111 | |||
6112 | return dest; | ||
6113 | } | ||
6114 | |||
6115 | static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src) | ||
6116 | { | ||
6117 | int mask=0x80,i; | ||
6118 | |||
6119 | for (i=0;i<4; ++i, mask>>=1) | ||
6120 | if (channel&mask) | ||
6121 | dest[i]=src[i]; | ||
6122 | } | ||
6123 | |||
6124 | static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result) | ||
6125 | { | ||
6126 | int act_comp=0,num_packets=0,y,chained; | ||
6127 | stbi__pic_packet packets[10]; | ||
6128 | |||
6129 | // this will (should...) cater for even some bizarre stuff like having data | ||
6130 | // for the same channel in multiple packets. | ||
6131 | do { | ||
6132 | stbi__pic_packet *packet; | ||
6133 | |||
6134 | if (num_packets==sizeof(packets)/sizeof(packets[0])) | ||
6135 | return stbi__errpuc("bad format","too many packets"); | ||
6136 | |||
6137 | packet = &packets[num_packets++]; | ||
6138 | |||
6139 | chained = stbi__get8(s); | ||
6140 | packet->size = stbi__get8(s); | ||
6141 | packet->type = stbi__get8(s); | ||
6142 | packet->channel = stbi__get8(s); | ||
6143 | |||
6144 | act_comp |= packet->channel; | ||
6145 | |||
6146 | if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (reading packets)"); | ||
6147 | if (packet->size != 8) return stbi__errpuc("bad format","packet isn't 8bpp"); | ||
6148 | } while (chained); | ||
6149 | |||
6150 | *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel? | ||
6151 | |||
6152 | for(y=0; y<height; ++y) { | ||
6153 | int packet_idx; | ||
6154 | |||
6155 | for(packet_idx=0; packet_idx < num_packets; ++packet_idx) { | ||
6156 | stbi__pic_packet *packet = &packets[packet_idx]; | ||
6157 | stbi_uc *dest = result+y*width*4; | ||
6158 | |||
6159 | switch (packet->type) { | ||
6160 | default: | ||
6161 | return stbi__errpuc("bad format","packet has bad compression type"); | ||
6162 | |||
6163 | case 0: {//uncompressed | ||
6164 | int x; | ||
6165 | |||
6166 | for(x=0;x<width;++x, dest+=4) | ||
6167 | if (!stbi__readval(s,packet->channel,dest)) | ||
6168 | return 0; | ||
6169 | break; | ||
6170 | } | ||
6171 | |||
6172 | case 1://Pure RLE | ||
6173 | { | ||
6174 | int left=width, i; | ||
6175 | |||
6176 | while (left>0) { | ||
6177 | stbi_uc count,value[4]; | ||
6178 | |||
6179 | count=stbi__get8(s); | ||
6180 | if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pure read count)"); | ||
6181 | |||
6182 | if (count > left) | ||
6183 | count = (stbi_uc) left; | ||
6184 | |||
6185 | if (!stbi__readval(s,packet->channel,value)) return 0; | ||
6186 | |||
6187 | for(i=0; i<count; ++i,dest+=4) | ||
6188 | stbi__copyval(packet->channel,dest,value); | ||
6189 | left -= count; | ||
6190 | } | ||
6191 | } | ||
6192 | break; | ||
6193 | |||
6194 | case 2: {//Mixed RLE | ||
6195 | int left=width; | ||
6196 | while (left>0) { | ||
6197 | int count = stbi__get8(s), i; | ||
6198 | if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (mixed read count)"); | ||
6199 | |||
6200 | if (count >= 128) { // Repeated | ||
6201 | stbi_uc value[4]; | ||
6202 | |||
6203 | if (count==128) | ||
6204 | count = stbi__get16be(s); | ||
6205 | else | ||
6206 | count -= 127; | ||
6207 | if (count > left) | ||
6208 | return stbi__errpuc("bad file","scanline overrun"); | ||
6209 | |||
6210 | if (!stbi__readval(s,packet->channel,value)) | ||
6211 | return 0; | ||
6212 | |||
6213 | for(i=0;i<count;++i, dest += 4) | ||
6214 | stbi__copyval(packet->channel,dest,value); | ||
6215 | } else { // Raw | ||
6216 | ++count; | ||
6217 | if (count>left) return stbi__errpuc("bad file","scanline overrun"); | ||
6218 | |||
6219 | for(i=0;i<count;++i, dest+=4) | ||
6220 | if (!stbi__readval(s,packet->channel,dest)) | ||
6221 | return 0; | ||
6222 | } | ||
6223 | left-=count; | ||
6224 | } | ||
6225 | break; | ||
6226 | } | ||
6227 | } | ||
6228 | } | ||
6229 | } | ||
6230 | |||
6231 | return result; | ||
6232 | } | ||
6233 | |||
6234 | static void *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp, stbi__result_info *ri) | ||
6235 | { | ||
6236 | stbi_uc *result; | ||
6237 | int i, x,y, internal_comp; | ||
6238 | STBI_NOTUSED(ri); | ||
6239 | |||
6240 | if (!comp) comp = &internal_comp; | ||
6241 | |||
6242 | for (i=0; i<92; ++i) | ||
6243 | stbi__get8(s); | ||
6244 | |||
6245 | x = stbi__get16be(s); | ||
6246 | y = stbi__get16be(s); | ||
6247 | if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pic header)"); | ||
6248 | if (!stbi__mad3sizes_valid(x, y, 4, 0)) return stbi__errpuc("too large", "PIC image too large to decode"); | ||
6249 | |||
6250 | stbi__get32be(s); //skip `ratio' | ||
6251 | stbi__get16be(s); //skip `fields' | ||
6252 | stbi__get16be(s); //skip `pad' | ||
6253 | |||
6254 | // intermediate buffer is RGBA | ||
6255 | result = (stbi_uc *) stbi__malloc_mad3(x, y, 4, 0); | ||
6256 | memset(result, 0xff, x*y*4); | ||
6257 | |||
6258 | if (!stbi__pic_load_core(s,x,y,comp, result)) { | ||
6259 | STBI_FREE(result); | ||
6260 | result=0; | ||
6261 | } | ||
6262 | *px = x; | ||
6263 | *py = y; | ||
6264 | if (req_comp == 0) req_comp = *comp; | ||
6265 | result=stbi__convert_format(result,4,req_comp,x,y); | ||
6266 | |||
6267 | return result; | ||
6268 | } | ||
6269 | |||
6270 | static int stbi__pic_test(stbi__context *s) | ||
6271 | { | ||
6272 | int r = stbi__pic_test_core(s); | ||
6273 | stbi__rewind(s); | ||
6274 | return r; | ||
6275 | } | ||
6276 | #endif | ||
6277 | |||
6278 | // ************************************************************************************************* | ||
6279 | // GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb | ||
6280 | |||
6281 | #ifndef STBI_NO_GIF | ||
6282 | typedef struct | ||
6283 | { | ||
6284 | stbi__int16 prefix; | ||
6285 | stbi_uc first; | ||
6286 | stbi_uc suffix; | ||
6287 | } stbi__gif_lzw; | ||
6288 | |||
6289 | typedef struct | ||
6290 | { | ||
6291 | int w,h; | ||
6292 | stbi_uc *out; // output buffer (always 4 components) | ||
6293 | stbi_uc *background; // The current "background" as far as a gif is concerned | ||
6294 | stbi_uc *history; | ||
6295 | int flags, bgindex, ratio, transparent, eflags; | ||
6296 | stbi_uc pal[256][4]; | ||
6297 | stbi_uc lpal[256][4]; | ||
6298 | stbi__gif_lzw codes[8192]; | ||
6299 | stbi_uc *color_table; | ||
6300 | int parse, step; | ||
6301 | int lflags; | ||
6302 | int start_x, start_y; | ||
6303 | int max_x, max_y; | ||
6304 | int cur_x, cur_y; | ||
6305 | int line_size; | ||
6306 | int delay; | ||
6307 | } stbi__gif; | ||
6308 | |||
6309 | static int stbi__gif_test_raw(stbi__context *s) | ||
6310 | { | ||
6311 | int sz; | ||
6312 | if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') return 0; | ||
6313 | sz = stbi__get8(s); | ||
6314 | if (sz != '9' && sz != '7') return 0; | ||
6315 | if (stbi__get8(s) != 'a') return 0; | ||
6316 | return 1; | ||
6317 | } | ||
6318 | |||
6319 | static int stbi__gif_test(stbi__context *s) | ||
6320 | { | ||
6321 | int r = stbi__gif_test_raw(s); | ||
6322 | stbi__rewind(s); | ||
6323 | return r; | ||
6324 | } | ||
6325 | |||
6326 | static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp) | ||
6327 | { | ||
6328 | int i; | ||
6329 | for (i=0; i < num_entries; ++i) { | ||
6330 | pal[i][2] = stbi__get8(s); | ||
6331 | pal[i][1] = stbi__get8(s); | ||
6332 | pal[i][0] = stbi__get8(s); | ||
6333 | pal[i][3] = transp == i ? 0 : 255; | ||
6334 | } | ||
6335 | } | ||
6336 | |||
6337 | static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info) | ||
6338 | { | ||
6339 | stbi_uc version; | ||
6340 | if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') | ||
6341 | return stbi__err("not GIF", "Corrupt GIF"); | ||
6342 | |||
6343 | version = stbi__get8(s); | ||
6344 | if (version != '7' && version != '9') return stbi__err("not GIF", "Corrupt GIF"); | ||
6345 | if (stbi__get8(s) != 'a') return stbi__err("not GIF", "Corrupt GIF"); | ||
6346 | |||
6347 | stbi__g_failure_reason = ""; | ||
6348 | g->w = stbi__get16le(s); | ||
6349 | g->h = stbi__get16le(s); | ||
6350 | g->flags = stbi__get8(s); | ||
6351 | g->bgindex = stbi__get8(s); | ||
6352 | g->ratio = stbi__get8(s); | ||
6353 | g->transparent = -1; | ||
6354 | |||
6355 | if (comp != 0) *comp = 4; // can't actually tell whether it's 3 or 4 until we parse the comments | ||
6356 | |||
6357 | if (is_info) return 1; | ||
6358 | |||
6359 | if (g->flags & 0x80) | ||
6360 | stbi__gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1); | ||
6361 | |||
6362 | return 1; | ||
6363 | } | ||
6364 | |||
6365 | static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp) | ||
6366 | { | ||
6367 | stbi__gif* g = (stbi__gif*) stbi__malloc(sizeof(stbi__gif)); | ||
6368 | if (!stbi__gif_header(s, g, comp, 1)) { | ||
6369 | STBI_FREE(g); | ||
6370 | stbi__rewind( s ); | ||
6371 | return 0; | ||
6372 | } | ||
6373 | if (x) *x = g->w; | ||
6374 | if (y) *y = g->h; | ||
6375 | STBI_FREE(g); | ||
6376 | return 1; | ||
6377 | } | ||
6378 | |||
6379 | static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code) | ||
6380 | { | ||
6381 | stbi_uc *p, *c; | ||
6382 | int idx; | ||
6383 | |||
6384 | // recurse to decode the prefixes, since the linked-list is backwards, | ||
6385 | // and working backwards through an interleaved image would be nasty | ||
6386 | if (g->codes[code].prefix >= 0) | ||
6387 | stbi__out_gif_code(g, g->codes[code].prefix); | ||
6388 | |||
6389 | if (g->cur_y >= g->max_y) return; | ||
6390 | |||
6391 | idx = g->cur_x + g->cur_y; | ||
6392 | p = &g->out[idx]; | ||
6393 | g->history[idx / 4] = 1; | ||
6394 | |||
6395 | c = &g->color_table[g->codes[code].suffix * 4]; | ||
6396 | if (c[3] > 128) { // don't render transparent pixels; | ||
6397 | p[0] = c[2]; | ||
6398 | p[1] = c[1]; | ||
6399 | p[2] = c[0]; | ||
6400 | p[3] = c[3]; | ||
6401 | } | ||
6402 | g->cur_x += 4; | ||
6403 | |||
6404 | if (g->cur_x >= g->max_x) { | ||
6405 | g->cur_x = g->start_x; | ||
6406 | g->cur_y += g->step; | ||
6407 | |||
6408 | while (g->cur_y >= g->max_y && g->parse > 0) { | ||
6409 | g->step = (1 << g->parse) * g->line_size; | ||
6410 | g->cur_y = g->start_y + (g->step >> 1); | ||
6411 | --g->parse; | ||
6412 | } | ||
6413 | } | ||
6414 | } | ||
6415 | |||
6416 | static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g) | ||
6417 | { | ||
6418 | stbi_uc lzw_cs; | ||
6419 | stbi__int32 len, init_code; | ||
6420 | stbi__uint32 first; | ||
6421 | stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear; | ||
6422 | stbi__gif_lzw *p; | ||
6423 | |||
6424 | lzw_cs = stbi__get8(s); | ||
6425 | if (lzw_cs > 12) return NULL; | ||
6426 | clear = 1 << lzw_cs; | ||
6427 | first = 1; | ||
6428 | codesize = lzw_cs + 1; | ||
6429 | codemask = (1 << codesize) - 1; | ||
6430 | bits = 0; | ||
6431 | valid_bits = 0; | ||
6432 | for (init_code = 0; init_code < clear; init_code++) { | ||
6433 | g->codes[init_code].prefix = -1; | ||
6434 | g->codes[init_code].first = (stbi_uc) init_code; | ||
6435 | g->codes[init_code].suffix = (stbi_uc) init_code; | ||
6436 | } | ||
6437 | |||
6438 | // support no starting clear code | ||
6439 | avail = clear+2; | ||
6440 | oldcode = -1; | ||
6441 | |||
6442 | len = 0; | ||
6443 | for(;;) { | ||
6444 | if (valid_bits < codesize) { | ||
6445 | if (len == 0) { | ||
6446 | len = stbi__get8(s); // start new block | ||
6447 | if (len == 0) | ||
6448 | return g->out; | ||
6449 | } | ||
6450 | --len; | ||
6451 | bits |= (stbi__int32) stbi__get8(s) << valid_bits; | ||
6452 | valid_bits += 8; | ||
6453 | } else { | ||
6454 | stbi__int32 code = bits & codemask; | ||
6455 | bits >>= codesize; | ||
6456 | valid_bits -= codesize; | ||
6457 | // @OPTIMIZE: is there some way we can accelerate the non-clear path? | ||
6458 | if (code == clear) { // clear code | ||
6459 | codesize = lzw_cs + 1; | ||
6460 | codemask = (1 << codesize) - 1; | ||
6461 | avail = clear + 2; | ||
6462 | oldcode = -1; | ||
6463 | first = 0; | ||
6464 | } else if (code == clear + 1) { // end of stream code | ||
6465 | stbi__skip(s, len); | ||
6466 | while ((len = stbi__get8(s)) > 0) | ||
6467 | stbi__skip(s,len); | ||
6468 | return g->out; | ||
6469 | } else if (code <= avail) { | ||
6470 | if (first) { | ||
6471 | return stbi__errpuc("no clear code", "Corrupt GIF"); | ||
6472 | } | ||
6473 | |||
6474 | if (oldcode >= 0) { | ||
6475 | p = &g->codes[avail++]; | ||
6476 | if (avail > 8192) { | ||
6477 | return stbi__errpuc("too many codes", "Corrupt GIF"); | ||
6478 | } | ||
6479 | |||
6480 | p->prefix = (stbi__int16) oldcode; | ||
6481 | p->first = g->codes[oldcode].first; | ||
6482 | p->suffix = (code == avail) ? p->first : g->codes[code].first; | ||
6483 | } else if (code == avail) | ||
6484 | return stbi__errpuc("illegal code in raster", "Corrupt GIF"); | ||
6485 | |||
6486 | stbi__out_gif_code(g, (stbi__uint16) code); | ||
6487 | |||
6488 | if ((avail & codemask) == 0 && avail <= 0x0FFF) { | ||
6489 | codesize++; | ||
6490 | codemask = (1 << codesize) - 1; | ||
6491 | } | ||
6492 | |||
6493 | oldcode = code; | ||
6494 | } else { | ||
6495 | return stbi__errpuc("illegal code in raster", "Corrupt GIF"); | ||
6496 | } | ||
6497 | } | ||
6498 | } | ||
6499 | } | ||
6500 | |||
6501 | // this function is designed to support animated gifs, although stb_image doesn't support it | ||
6502 | // two back is the image from two frames ago, used for a very specific disposal format | ||
6503 | static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stbi_uc *two_back) | ||
6504 | { | ||
6505 | int dispose; | ||
6506 | int first_frame; | ||
6507 | int pi; | ||
6508 | int pcount; | ||
6509 | STBI_NOTUSED(req_comp); | ||
6510 | |||
6511 | // on first frame, any non-written pixels get the background colour (non-transparent) | ||
6512 | first_frame = 0; | ||
6513 | if (g->out == 0) { | ||
6514 | if (!stbi__gif_header(s, g, comp,0)) return 0; // stbi__g_failure_reason set by stbi__gif_header | ||
6515 | if (!stbi__mad3sizes_valid(4, g->w, g->h, 0)) | ||
6516 | return stbi__errpuc("too large", "GIF image is too large"); | ||
6517 | pcount = g->w * g->h; | ||
6518 | g->out = (stbi_uc *) stbi__malloc(4 * pcount); | ||
6519 | g->background = (stbi_uc *) stbi__malloc(4 * pcount); | ||
6520 | g->history = (stbi_uc *) stbi__malloc(pcount); | ||
6521 | if (!g->out || !g->background || !g->history) | ||
6522 | return stbi__errpuc("outofmem", "Out of memory"); | ||
6523 | |||
6524 | // image is treated as "transparent" at the start - ie, nothing overwrites the current background; | ||
6525 | // background colour is only used for pixels that are not rendered first frame, after that "background" | ||
6526 | // color refers to the color that was there the previous frame. | ||
6527 | memset(g->out, 0x00, 4 * pcount); | ||
6528 | memset(g->background, 0x00, 4 * pcount); // state of the background (starts transparent) | ||
6529 | memset(g->history, 0x00, pcount); // pixels that were affected previous frame | ||
6530 | first_frame = 1; | ||
6531 | } else { | ||
6532 | // second frame - how do we dispoase of the previous one? | ||
6533 | dispose = (g->eflags & 0x1C) >> 2; | ||
6534 | pcount = g->w * g->h; | ||
6535 | |||
6536 | if ((dispose == 3) && (two_back == 0)) { | ||
6537 | dispose = 2; // if I don't have an image to revert back to, default to the old background | ||
6538 | } | ||
6539 | |||
6540 | if (dispose == 3) { // use previous graphic | ||
6541 | for (pi = 0; pi < pcount; ++pi) { | ||
6542 | if (g->history[pi]) { | ||
6543 | memcpy( &g->out[pi * 4], &two_back[pi * 4], 4 ); | ||
6544 | } | ||
6545 | } | ||
6546 | } else if (dispose == 2) { | ||
6547 | // restore what was changed last frame to background before that frame; | ||
6548 | for (pi = 0; pi < pcount; ++pi) { | ||
6549 | if (g->history[pi]) { | ||
6550 | memcpy( &g->out[pi * 4], &g->background[pi * 4], 4 ); | ||
6551 | } | ||
6552 | } | ||
6553 | } else { | ||
6554 | // This is a non-disposal case eithe way, so just | ||
6555 | // leave the pixels as is, and they will become the new background | ||
6556 | // 1: do not dispose | ||
6557 | // 0: not specified. | ||
6558 | } | ||
6559 | |||
6560 | // background is what out is after the undoing of the previou frame; | ||
6561 | memcpy( g->background, g->out, 4 * g->w * g->h ); | ||
6562 | } | ||
6563 | |||
6564 | // clear my history; | ||
6565 | memset( g->history, 0x00, g->w * g->h ); // pixels that were affected previous frame | ||
6566 | |||
6567 | for (;;) { | ||
6568 | int tag = stbi__get8(s); | ||
6569 | switch (tag) { | ||
6570 | case 0x2C: /* Image Descriptor */ | ||
6571 | { | ||
6572 | stbi__int32 x, y, w, h; | ||
6573 | stbi_uc *o; | ||
6574 | |||
6575 | x = stbi__get16le(s); | ||
6576 | y = stbi__get16le(s); | ||
6577 | w = stbi__get16le(s); | ||
6578 | h = stbi__get16le(s); | ||
6579 | if (((x + w) > (g->w)) || ((y + h) > (g->h))) | ||
6580 | return stbi__errpuc("bad Image Descriptor", "Corrupt GIF"); | ||
6581 | |||
6582 | g->line_size = g->w * 4; | ||
6583 | g->start_x = x * 4; | ||
6584 | g->start_y = y * g->line_size; | ||
6585 | g->max_x = g->start_x + w * 4; | ||
6586 | g->max_y = g->start_y + h * g->line_size; | ||
6587 | g->cur_x = g->start_x; | ||
6588 | g->cur_y = g->start_y; | ||
6589 | |||
6590 | // if the width of the specified rectangle is 0, that means | ||
6591 | // we may not see *any* pixels or the image is malformed; | ||
6592 | // to make sure this is caught, move the current y down to | ||
6593 | // max_y (which is what out_gif_code checks). | ||
6594 | if (w == 0) | ||
6595 | g->cur_y = g->max_y; | ||
6596 | |||
6597 | g->lflags = stbi__get8(s); | ||
6598 | |||
6599 | if (g->lflags & 0x40) { | ||
6600 | g->step = 8 * g->line_size; // first interlaced spacing | ||
6601 | g->parse = 3; | ||
6602 | } else { | ||
6603 | g->step = g->line_size; | ||
6604 | g->parse = 0; | ||
6605 | } | ||
6606 | |||
6607 | if (g->lflags & 0x80) { | ||
6608 | stbi__gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1); | ||
6609 | g->color_table = (stbi_uc *) g->lpal; | ||
6610 | } else if (g->flags & 0x80) { | ||
6611 | g->color_table = (stbi_uc *) g->pal; | ||
6612 | } else | ||
6613 | return stbi__errpuc("missing color table", "Corrupt GIF"); | ||
6614 | |||
6615 | o = stbi__process_gif_raster(s, g); | ||
6616 | if (!o) return NULL; | ||
6617 | |||
6618 | // if this was the first frame, | ||
6619 | pcount = g->w * g->h; | ||
6620 | if (first_frame && (g->bgindex > 0)) { | ||
6621 | // if first frame, any pixel not drawn to gets the background color | ||
6622 | for (pi = 0; pi < pcount; ++pi) { | ||
6623 | if (g->history[pi] == 0) { | ||
6624 | g->pal[g->bgindex][3] = 255; // just in case it was made transparent, undo that; It will be reset next frame if need be; | ||
6625 | memcpy( &g->out[pi * 4], &g->pal[g->bgindex], 4 ); | ||
6626 | } | ||
6627 | } | ||
6628 | } | ||
6629 | |||
6630 | return o; | ||
6631 | } | ||
6632 | |||
6633 | case 0x21: // Comment Extension. | ||
6634 | { | ||
6635 | int len; | ||
6636 | int ext = stbi__get8(s); | ||
6637 | if (ext == 0xF9) { // Graphic Control Extension. | ||
6638 | len = stbi__get8(s); | ||
6639 | if (len == 4) { | ||
6640 | g->eflags = stbi__get8(s); | ||
6641 | g->delay = 10 * stbi__get16le(s); // delay - 1/100th of a second, saving as 1/1000ths. | ||
6642 | |||
6643 | // unset old transparent | ||
6644 | if (g->transparent >= 0) { | ||
6645 | g->pal[g->transparent][3] = 255; | ||
6646 | } | ||
6647 | if (g->eflags & 0x01) { | ||
6648 | g->transparent = stbi__get8(s); | ||
6649 | if (g->transparent >= 0) { | ||
6650 | g->pal[g->transparent][3] = 0; | ||
6651 | } | ||
6652 | } else { | ||
6653 | // don't need transparent | ||
6654 | stbi__skip(s, 1); | ||
6655 | g->transparent = -1; | ||
6656 | } | ||
6657 | } else { | ||
6658 | stbi__skip(s, len); | ||
6659 | break; | ||
6660 | } | ||
6661 | } | ||
6662 | while ((len = stbi__get8(s)) != 0) { | ||
6663 | stbi__skip(s, len); | ||
6664 | } | ||
6665 | break; | ||
6666 | } | ||
6667 | |||
6668 | case 0x3B: // gif stream termination code | ||
6669 | return (stbi_uc *) s; // using '1' causes warning on some compilers | ||
6670 | |||
6671 | default: | ||
6672 | return stbi__errpuc("unknown code", "Corrupt GIF"); | ||
6673 | } | ||
6674 | } | ||
6675 | } | ||
6676 | |||
6677 | static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp) | ||
6678 | { | ||
6679 | if (stbi__gif_test(s)) { | ||
6680 | int layers = 0; | ||
6681 | stbi_uc *u = 0; | ||
6682 | stbi_uc *out = 0; | ||
6683 | stbi_uc *two_back = 0; | ||
6684 | stbi__gif g; | ||
6685 | int stride; | ||
6686 | memset(&g, 0, sizeof(g)); | ||
6687 | if (delays) { | ||
6688 | *delays = 0; | ||
6689 | } | ||
6690 | |||
6691 | do { | ||
6692 | u = stbi__gif_load_next(s, &g, comp, req_comp, two_back); | ||
6693 | if (u == (stbi_uc *) s) u = 0; // end of animated gif marker | ||
6694 | |||
6695 | if (u) { | ||
6696 | *x = g.w; | ||
6697 | *y = g.h; | ||
6698 | ++layers; | ||
6699 | stride = g.w * g.h * 4; | ||
6700 | |||
6701 | if (out) { | ||
6702 | void *tmp = (stbi_uc*) STBI_REALLOC( out, layers * stride ); | ||
6703 | if (NULL == tmp) { | ||
6704 | STBI_FREE(g.out); | ||
6705 | STBI_FREE(g.history); | ||
6706 | STBI_FREE(g.background); | ||
6707 | return stbi__errpuc("outofmem", "Out of memory"); | ||
6708 | } | ||
6709 | else | ||
6710 | out = (stbi_uc*) tmp; | ||
6711 | if (delays) { | ||
6712 | *delays = (int*) STBI_REALLOC( *delays, sizeof(int) * layers ); | ||
6713 | } | ||
6714 | } else { | ||
6715 | out = (stbi_uc*)stbi__malloc( layers * stride ); | ||
6716 | if (delays) { | ||
6717 | *delays = (int*) stbi__malloc( layers * sizeof(int) ); | ||
6718 | } | ||
6719 | } | ||
6720 | memcpy( out + ((layers - 1) * stride), u, stride ); | ||
6721 | if (layers >= 2) { | ||
6722 | two_back = out - 2 * stride; | ||
6723 | } | ||
6724 | |||
6725 | if (delays) { | ||
6726 | (*delays)[layers - 1U] = g.delay; | ||
6727 | } | ||
6728 | } | ||
6729 | } while (u != 0); | ||
6730 | |||
6731 | // free temp buffer; | ||
6732 | STBI_FREE(g.out); | ||
6733 | STBI_FREE(g.history); | ||
6734 | STBI_FREE(g.background); | ||
6735 | |||
6736 | // do the final conversion after loading everything; | ||
6737 | if (req_comp && req_comp != 4) | ||
6738 | out = stbi__convert_format(out, 4, req_comp, layers * g.w, g.h); | ||
6739 | |||
6740 | *z = layers; | ||
6741 | return out; | ||
6742 | } else { | ||
6743 | return stbi__errpuc("not GIF", "Image was not as a gif type."); | ||
6744 | } | ||
6745 | } | ||
6746 | |||
6747 | static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) | ||
6748 | { | ||
6749 | stbi_uc *u = 0; | ||
6750 | stbi__gif g; | ||
6751 | memset(&g, 0, sizeof(g)); | ||
6752 | STBI_NOTUSED(ri); | ||
6753 | |||
6754 | u = stbi__gif_load_next(s, &g, comp, req_comp, 0); | ||
6755 | if (u == (stbi_uc *) s) u = 0; // end of animated gif marker | ||
6756 | if (u) { | ||
6757 | *x = g.w; | ||
6758 | *y = g.h; | ||
6759 | |||
6760 | // moved conversion to after successful load so that the same | ||
6761 | // can be done for multiple frames. | ||
6762 | if (req_comp && req_comp != 4) | ||
6763 | u = stbi__convert_format(u, 4, req_comp, g.w, g.h); | ||
6764 | } else if (g.out) { | ||
6765 | // if there was an error and we allocated an image buffer, free it! | ||
6766 | STBI_FREE(g.out); | ||
6767 | } | ||
6768 | |||
6769 | // free buffers needed for multiple frame loading; | ||
6770 | STBI_FREE(g.history); | ||
6771 | STBI_FREE(g.background); | ||
6772 | |||
6773 | return u; | ||
6774 | } | ||
6775 | |||
6776 | static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp) | ||
6777 | { | ||
6778 | return stbi__gif_info_raw(s,x,y,comp); | ||
6779 | } | ||
6780 | #endif | ||
6781 | |||
6782 | // ************************************************************************************************* | ||
6783 | // Radiance RGBE HDR loader | ||
6784 | // originally by Nicolas Schulz | ||
6785 | #ifndef STBI_NO_HDR | ||
6786 | static int stbi__hdr_test_core(stbi__context *s, const char *signature) | ||
6787 | { | ||
6788 | int i; | ||
6789 | for (i=0; signature[i]; ++i) | ||
6790 | if (stbi__get8(s) != signature[i]) | ||
6791 | return 0; | ||
6792 | stbi__rewind(s); | ||
6793 | return 1; | ||
6794 | } | ||
6795 | |||
6796 | static int stbi__hdr_test(stbi__context* s) | ||
6797 | { | ||
6798 | int r = stbi__hdr_test_core(s, "#?RADIANCE\n"); | ||
6799 | stbi__rewind(s); | ||
6800 | if(!r) { | ||
6801 | r = stbi__hdr_test_core(s, "#?RGBE\n"); | ||
6802 | stbi__rewind(s); | ||
6803 | } | ||
6804 | return r; | ||
6805 | } | ||
6806 | |||
6807 | #define STBI__HDR_BUFLEN 1024 | ||
6808 | static char *stbi__hdr_gettoken(stbi__context *z, char *buffer) | ||
6809 | { | ||
6810 | int len=0; | ||
6811 | char c = '\0'; | ||
6812 | |||
6813 | c = (char) stbi__get8(z); | ||
6814 | |||
6815 | while (!stbi__at_eof(z) && c != '\n') { | ||
6816 | buffer[len++] = c; | ||
6817 | if (len == STBI__HDR_BUFLEN-1) { | ||
6818 | // flush to end of line | ||
6819 | while (!stbi__at_eof(z) && stbi__get8(z) != '\n') | ||
6820 | ; | ||
6821 | break; | ||
6822 | } | ||
6823 | c = (char) stbi__get8(z); | ||
6824 | } | ||
6825 | |||
6826 | buffer[len] = 0; | ||
6827 | return buffer; | ||
6828 | } | ||
6829 | |||
6830 | static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp) | ||
6831 | { | ||
6832 | if ( input[3] != 0 ) { | ||
6833 | float f1; | ||
6834 | // Exponent | ||
6835 | f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8)); | ||
6836 | if (req_comp <= 2) | ||
6837 | output[0] = (input[0] + input[1] + input[2]) * f1 / 3; | ||
6838 | else { | ||
6839 | output[0] = input[0] * f1; | ||
6840 | output[1] = input[1] * f1; | ||
6841 | output[2] = input[2] * f1; | ||
6842 | } | ||
6843 | if (req_comp == 2) output[1] = 1; | ||
6844 | if (req_comp == 4) output[3] = 1; | ||
6845 | } else { | ||
6846 | switch (req_comp) { | ||
6847 | case 4: output[3] = 1; /* fallthrough */ | ||
6848 | case 3: output[0] = output[1] = output[2] = 0; | ||
6849 | break; | ||
6850 | case 2: output[1] = 1; /* fallthrough */ | ||
6851 | case 1: output[0] = 0; | ||
6852 | break; | ||
6853 | } | ||
6854 | } | ||
6855 | } | ||
6856 | |||
6857 | static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) | ||
6858 | { | ||
6859 | char buffer[STBI__HDR_BUFLEN]; | ||
6860 | char *token; | ||
6861 | int valid = 0; | ||
6862 | int width, height; | ||
6863 | stbi_uc *scanline; | ||
6864 | float *hdr_data; | ||
6865 | int len; | ||
6866 | unsigned char count, value; | ||
6867 | int i, j, k, c1,c2, z; | ||
6868 | const char *headerToken; | ||
6869 | STBI_NOTUSED(ri); | ||
6870 | |||
6871 | // Check identifier | ||
6872 | headerToken = stbi__hdr_gettoken(s,buffer); | ||
6873 | if (strcmp(headerToken, "#?RADIANCE") != 0 && strcmp(headerToken, "#?RGBE") != 0) | ||
6874 | return stbi__errpf("not HDR", "Corrupt HDR image"); | ||
6875 | |||
6876 | // Parse header | ||
6877 | for(;;) { | ||
6878 | token = stbi__hdr_gettoken(s,buffer); | ||
6879 | if (token[0] == 0) break; | ||
6880 | if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; | ||
6881 | } | ||
6882 | |||
6883 | if (!valid) return stbi__errpf("unsupported format", "Unsupported HDR format"); | ||
6884 | |||
6885 | // Parse width and height | ||
6886 | // can't use sscanf() if we're not using stdio! | ||
6887 | token = stbi__hdr_gettoken(s,buffer); | ||
6888 | if (strncmp(token, "-Y ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); | ||
6889 | token += 3; | ||
6890 | height = (int) strtol(token, &token, 10); | ||
6891 | while (*token == ' ') ++token; | ||
6892 | if (strncmp(token, "+X ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); | ||
6893 | token += 3; | ||
6894 | width = (int) strtol(token, NULL, 10); | ||
6895 | |||
6896 | *x = width; | ||
6897 | *y = height; | ||
6898 | |||
6899 | if (comp) *comp = 3; | ||
6900 | if (req_comp == 0) req_comp = 3; | ||
6901 | |||
6902 | if (!stbi__mad4sizes_valid(width, height, req_comp, sizeof(float), 0)) | ||
6903 | return stbi__errpf("too large", "HDR image is too large"); | ||
6904 | |||
6905 | // Read data | ||
6906 | hdr_data = (float *) stbi__malloc_mad4(width, height, req_comp, sizeof(float), 0); | ||
6907 | if (!hdr_data) | ||
6908 | return stbi__errpf("outofmem", "Out of memory"); | ||
6909 | |||
6910 | // Load image data | ||
6911 | // image data is stored as some number of sca | ||
6912 | if ( width < 8 || width >= 32768) { | ||
6913 | // Read flat data | ||
6914 | for (j=0; j < height; ++j) { | ||
6915 | for (i=0; i < width; ++i) { | ||
6916 | stbi_uc rgbe[4]; | ||
6917 | main_decode_loop: | ||
6918 | stbi__getn(s, rgbe, 4); | ||
6919 | stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp); | ||
6920 | } | ||
6921 | } | ||
6922 | } else { | ||
6923 | // Read RLE-encoded data | ||
6924 | scanline = NULL; | ||
6925 | |||
6926 | for (j = 0; j < height; ++j) { | ||
6927 | c1 = stbi__get8(s); | ||
6928 | c2 = stbi__get8(s); | ||
6929 | len = stbi__get8(s); | ||
6930 | if (c1 != 2 || c2 != 2 || (len & 0x80)) { | ||
6931 | // not run-length encoded, so we have to actually use THIS data as a decoded | ||
6932 | // pixel (note this can't be a valid pixel--one of RGB must be >= 128) | ||
6933 | stbi_uc rgbe[4]; | ||
6934 | rgbe[0] = (stbi_uc) c1; | ||
6935 | rgbe[1] = (stbi_uc) c2; | ||
6936 | rgbe[2] = (stbi_uc) len; | ||
6937 | rgbe[3] = (stbi_uc) stbi__get8(s); | ||
6938 | stbi__hdr_convert(hdr_data, rgbe, req_comp); | ||
6939 | i = 1; | ||
6940 | j = 0; | ||
6941 | STBI_FREE(scanline); | ||
6942 | goto main_decode_loop; // yes, this makes no sense | ||
6943 | } | ||
6944 | len <<= 8; | ||
6945 | len |= stbi__get8(s); | ||
6946 | if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); } | ||
6947 | if (scanline == NULL) { | ||
6948 | scanline = (stbi_uc *) stbi__malloc_mad2(width, 4, 0); | ||
6949 | if (!scanline) { | ||
6950 | STBI_FREE(hdr_data); | ||
6951 | return stbi__errpf("outofmem", "Out of memory"); | ||
6952 | } | ||
6953 | } | ||
6954 | |||
6955 | for (k = 0; k < 4; ++k) { | ||
6956 | int nleft; | ||
6957 | i = 0; | ||
6958 | while ((nleft = width - i) > 0) { | ||
6959 | count = stbi__get8(s); | ||
6960 | if (count > 128) { | ||
6961 | // Run | ||
6962 | value = stbi__get8(s); | ||
6963 | count -= 128; | ||
6964 | if (count > nleft) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } | ||
6965 | for (z = 0; z < count; ++z) | ||
6966 | scanline[i++ * 4 + k] = value; | ||
6967 | } else { | ||
6968 | // Dump | ||
6969 | if (count > nleft) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } | ||
6970 | for (z = 0; z < count; ++z) | ||
6971 | scanline[i++ * 4 + k] = stbi__get8(s); | ||
6972 | } | ||
6973 | } | ||
6974 | } | ||
6975 | for (i=0; i < width; ++i) | ||
6976 | stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp); | ||
6977 | } | ||
6978 | if (scanline) | ||
6979 | STBI_FREE(scanline); | ||
6980 | } | ||
6981 | |||
6982 | return hdr_data; | ||
6983 | } | ||
6984 | |||
6985 | static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp) | ||
6986 | { | ||
6987 | char buffer[STBI__HDR_BUFLEN]; | ||
6988 | char *token; | ||
6989 | int valid = 0; | ||
6990 | int dummy; | ||
6991 | |||
6992 | if (!x) x = &dummy; | ||
6993 | if (!y) y = &dummy; | ||
6994 | if (!comp) comp = &dummy; | ||
6995 | |||
6996 | if (stbi__hdr_test(s) == 0) { | ||
6997 | stbi__rewind( s ); | ||
6998 | return 0; | ||
6999 | } | ||
7000 | |||
7001 | for(;;) { | ||
7002 | token = stbi__hdr_gettoken(s,buffer); | ||
7003 | if (token[0] == 0) break; | ||
7004 | if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; | ||
7005 | } | ||
7006 | |||
7007 | if (!valid) { | ||
7008 | stbi__rewind( s ); | ||
7009 | return 0; | ||
7010 | } | ||
7011 | token = stbi__hdr_gettoken(s,buffer); | ||
7012 | if (strncmp(token, "-Y ", 3)) { | ||
7013 | stbi__rewind( s ); | ||
7014 | return 0; | ||
7015 | } | ||
7016 | token += 3; | ||
7017 | *y = (int) strtol(token, &token, 10); | ||
7018 | while (*token == ' ') ++token; | ||
7019 | if (strncmp(token, "+X ", 3)) { | ||
7020 | stbi__rewind( s ); | ||
7021 | return 0; | ||
7022 | } | ||
7023 | token += 3; | ||
7024 | *x = (int) strtol(token, NULL, 10); | ||
7025 | *comp = 3; | ||
7026 | return 1; | ||
7027 | } | ||
7028 | #endif // STBI_NO_HDR | ||
7029 | |||
7030 | #ifndef STBI_NO_BMP | ||
7031 | static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp) | ||
7032 | { | ||
7033 | void *p; | ||
7034 | stbi__bmp_data info; | ||
7035 | |||
7036 | info.all_a = 255; | ||
7037 | p = stbi__bmp_parse_header(s, &info); | ||
7038 | stbi__rewind( s ); | ||
7039 | if (p == NULL) | ||
7040 | return 0; | ||
7041 | if (x) *x = s->img_x; | ||
7042 | if (y) *y = s->img_y; | ||
7043 | if (comp) { | ||
7044 | if (info.bpp == 24 && info.ma == 0xff000000) | ||
7045 | *comp = 3; | ||
7046 | else | ||
7047 | *comp = info.ma ? 4 : 3; | ||
7048 | } | ||
7049 | return 1; | ||
7050 | } | ||
7051 | #endif | ||
7052 | |||
7053 | #ifndef STBI_NO_PSD | ||
7054 | static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp) | ||
7055 | { | ||
7056 | int channelCount, dummy, depth; | ||
7057 | if (!x) x = &dummy; | ||
7058 | if (!y) y = &dummy; | ||
7059 | if (!comp) comp = &dummy; | ||
7060 | if (stbi__get32be(s) != 0x38425053) { | ||
7061 | stbi__rewind( s ); | ||
7062 | return 0; | ||
7063 | } | ||
7064 | if (stbi__get16be(s) != 1) { | ||
7065 | stbi__rewind( s ); | ||
7066 | return 0; | ||
7067 | } | ||
7068 | stbi__skip(s, 6); | ||
7069 | channelCount = stbi__get16be(s); | ||
7070 | if (channelCount < 0 || channelCount > 16) { | ||
7071 | stbi__rewind( s ); | ||
7072 | return 0; | ||
7073 | } | ||
7074 | *y = stbi__get32be(s); | ||
7075 | *x = stbi__get32be(s); | ||
7076 | depth = stbi__get16be(s); | ||
7077 | if (depth != 8 && depth != 16) { | ||
7078 | stbi__rewind( s ); | ||
7079 | return 0; | ||
7080 | } | ||
7081 | if (stbi__get16be(s) != 3) { | ||
7082 | stbi__rewind( s ); | ||
7083 | return 0; | ||
7084 | } | ||
7085 | *comp = 4; | ||
7086 | return 1; | ||
7087 | } | ||
7088 | |||
7089 | static int stbi__psd_is16(stbi__context *s) | ||
7090 | { | ||
7091 | int channelCount, depth; | ||
7092 | if (stbi__get32be(s) != 0x38425053) { | ||
7093 | stbi__rewind( s ); | ||
7094 | return 0; | ||
7095 | } | ||
7096 | if (stbi__get16be(s) != 1) { | ||
7097 | stbi__rewind( s ); | ||
7098 | return 0; | ||
7099 | } | ||
7100 | stbi__skip(s, 6); | ||
7101 | channelCount = stbi__get16be(s); | ||
7102 | if (channelCount < 0 || channelCount > 16) { | ||
7103 | stbi__rewind( s ); | ||
7104 | return 0; | ||
7105 | } | ||
7106 | (void) stbi__get32be(s); | ||
7107 | (void) stbi__get32be(s); | ||
7108 | depth = stbi__get16be(s); | ||
7109 | if (depth != 16) { | ||
7110 | stbi__rewind( s ); | ||
7111 | return 0; | ||
7112 | } | ||
7113 | return 1; | ||
7114 | } | ||
7115 | #endif | ||
7116 | |||
7117 | #ifndef STBI_NO_PIC | ||
7118 | static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp) | ||
7119 | { | ||
7120 | int act_comp=0,num_packets=0,chained,dummy; | ||
7121 | stbi__pic_packet packets[10]; | ||
7122 | |||
7123 | if (!x) x = &dummy; | ||
7124 | if (!y) y = &dummy; | ||
7125 | if (!comp) comp = &dummy; | ||
7126 | |||
7127 | if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) { | ||
7128 | stbi__rewind(s); | ||
7129 | return 0; | ||
7130 | } | ||
7131 | |||
7132 | stbi__skip(s, 88); | ||
7133 | |||
7134 | *x = stbi__get16be(s); | ||
7135 | *y = stbi__get16be(s); | ||
7136 | if (stbi__at_eof(s)) { | ||
7137 | stbi__rewind( s); | ||
7138 | return 0; | ||
7139 | } | ||
7140 | if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) { | ||
7141 | stbi__rewind( s ); | ||
7142 | return 0; | ||
7143 | } | ||
7144 | |||
7145 | stbi__skip(s, 8); | ||
7146 | |||
7147 | do { | ||
7148 | stbi__pic_packet *packet; | ||
7149 | |||
7150 | if (num_packets==sizeof(packets)/sizeof(packets[0])) | ||
7151 | return 0; | ||
7152 | |||
7153 | packet = &packets[num_packets++]; | ||
7154 | chained = stbi__get8(s); | ||
7155 | packet->size = stbi__get8(s); | ||
7156 | packet->type = stbi__get8(s); | ||
7157 | packet->channel = stbi__get8(s); | ||
7158 | act_comp |= packet->channel; | ||
7159 | |||
7160 | if (stbi__at_eof(s)) { | ||
7161 | stbi__rewind( s ); | ||
7162 | return 0; | ||
7163 | } | ||
7164 | if (packet->size != 8) { | ||
7165 | stbi__rewind( s ); | ||
7166 | return 0; | ||
7167 | } | ||
7168 | } while (chained); | ||
7169 | |||
7170 | *comp = (act_comp & 0x10 ? 4 : 3); | ||
7171 | |||
7172 | return 1; | ||
7173 | } | ||
7174 | #endif | ||
7175 | |||
7176 | // ************************************************************************************************* | ||
7177 | // Portable Gray Map and Portable Pixel Map loader | ||
7178 | // by Ken Miller | ||
7179 | // | ||
7180 | // PGM: http://netpbm.sourceforge.net/doc/pgm.html | ||
7181 | // PPM: http://netpbm.sourceforge.net/doc/ppm.html | ||
7182 | // | ||
7183 | // Known limitations: | ||
7184 | // Does not support comments in the header section | ||
7185 | // Does not support ASCII image data (formats P2 and P3) | ||
7186 | // Does not support 16-bit-per-channel | ||
7187 | |||
7188 | #ifndef STBI_NO_PNM | ||
7189 | |||
7190 | static int stbi__pnm_test(stbi__context *s) | ||
7191 | { | ||
7192 | char p, t; | ||
7193 | p = (char) stbi__get8(s); | ||
7194 | t = (char) stbi__get8(s); | ||
7195 | if (p != 'P' || (t != '5' && t != '6')) { | ||
7196 | stbi__rewind( s ); | ||
7197 | return 0; | ||
7198 | } | ||
7199 | return 1; | ||
7200 | } | ||
7201 | |||
7202 | static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) | ||
7203 | { | ||
7204 | stbi_uc *out; | ||
7205 | STBI_NOTUSED(ri); | ||
7206 | |||
7207 | if (!stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n)) | ||
7208 | return 0; | ||
7209 | |||
7210 | *x = s->img_x; | ||
7211 | *y = s->img_y; | ||
7212 | if (comp) *comp = s->img_n; | ||
7213 | |||
7214 | if (!stbi__mad3sizes_valid(s->img_n, s->img_x, s->img_y, 0)) | ||
7215 | return stbi__errpuc("too large", "PNM too large"); | ||
7216 | |||
7217 | out = (stbi_uc *) stbi__malloc_mad3(s->img_n, s->img_x, s->img_y, 0); | ||
7218 | if (!out) return stbi__errpuc("outofmem", "Out of memory"); | ||
7219 | stbi__getn(s, out, s->img_n * s->img_x * s->img_y); | ||
7220 | |||
7221 | if (req_comp && req_comp != s->img_n) { | ||
7222 | out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y); | ||
7223 | if (out == NULL) return out; // stbi__convert_format frees input on failure | ||
7224 | } | ||
7225 | return out; | ||
7226 | } | ||
7227 | |||
7228 | static int stbi__pnm_isspace(char c) | ||
7229 | { | ||
7230 | return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r'; | ||
7231 | } | ||
7232 | |||
7233 | static void stbi__pnm_skip_whitespace(stbi__context *s, char *c) | ||
7234 | { | ||
7235 | for (;;) { | ||
7236 | while (!stbi__at_eof(s) && stbi__pnm_isspace(*c)) | ||
7237 | *c = (char) stbi__get8(s); | ||
7238 | |||
7239 | if (stbi__at_eof(s) || *c != '#') | ||
7240 | break; | ||
7241 | |||
7242 | while (!stbi__at_eof(s) && *c != '\n' && *c != '\r' ) | ||
7243 | *c = (char) stbi__get8(s); | ||
7244 | } | ||
7245 | } | ||
7246 | |||
7247 | static int stbi__pnm_isdigit(char c) | ||
7248 | { | ||
7249 | return c >= '0' && c <= '9'; | ||
7250 | } | ||
7251 | |||
7252 | static int stbi__pnm_getinteger(stbi__context *s, char *c) | ||
7253 | { | ||
7254 | int value = 0; | ||
7255 | |||
7256 | while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) { | ||
7257 | value = value*10 + (*c - '0'); | ||
7258 | *c = (char) stbi__get8(s); | ||
7259 | } | ||
7260 | |||
7261 | return value; | ||
7262 | } | ||
7263 | |||
7264 | static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp) | ||
7265 | { | ||
7266 | int maxv, dummy; | ||
7267 | char c, p, t; | ||
7268 | |||
7269 | if (!x) x = &dummy; | ||
7270 | if (!y) y = &dummy; | ||
7271 | if (!comp) comp = &dummy; | ||
7272 | |||
7273 | stbi__rewind(s); | ||
7274 | |||
7275 | // Get identifier | ||
7276 | p = (char) stbi__get8(s); | ||
7277 | t = (char) stbi__get8(s); | ||
7278 | if (p != 'P' || (t != '5' && t != '6')) { | ||
7279 | stbi__rewind(s); | ||
7280 | return 0; | ||
7281 | } | ||
7282 | |||
7283 | *comp = (t == '6') ? 3 : 1; // '5' is 1-component .pgm; '6' is 3-component .ppm | ||
7284 | |||
7285 | c = (char) stbi__get8(s); | ||
7286 | stbi__pnm_skip_whitespace(s, &c); | ||
7287 | |||
7288 | *x = stbi__pnm_getinteger(s, &c); // read width | ||
7289 | stbi__pnm_skip_whitespace(s, &c); | ||
7290 | |||
7291 | *y = stbi__pnm_getinteger(s, &c); // read height | ||
7292 | stbi__pnm_skip_whitespace(s, &c); | ||
7293 | |||
7294 | maxv = stbi__pnm_getinteger(s, &c); // read max value | ||
7295 | |||
7296 | if (maxv > 255) | ||
7297 | return stbi__err("max value > 255", "PPM image not 8-bit"); | ||
7298 | else | ||
7299 | return 1; | ||
7300 | } | ||
7301 | #endif | ||
7302 | |||
7303 | static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp) | ||
7304 | { | ||
7305 | #ifndef STBI_NO_JPEG | ||
7306 | if (stbi__jpeg_info(s, x, y, comp)) return 1; | ||
7307 | #endif | ||
7308 | |||
7309 | #ifndef STBI_NO_PNG | ||
7310 | if (stbi__png_info(s, x, y, comp)) return 1; | ||
7311 | #endif | ||
7312 | |||
7313 | #ifndef STBI_NO_GIF | ||
7314 | if (stbi__gif_info(s, x, y, comp)) return 1; | ||
7315 | #endif | ||
7316 | |||
7317 | #ifndef STBI_NO_BMP | ||
7318 | if (stbi__bmp_info(s, x, y, comp)) return 1; | ||
7319 | #endif | ||
7320 | |||
7321 | #ifndef STBI_NO_PSD | ||
7322 | if (stbi__psd_info(s, x, y, comp)) return 1; | ||
7323 | #endif | ||
7324 | |||
7325 | #ifndef STBI_NO_PIC | ||
7326 | if (stbi__pic_info(s, x, y, comp)) return 1; | ||
7327 | #endif | ||
7328 | |||
7329 | #ifndef STBI_NO_PNM | ||
7330 | if (stbi__pnm_info(s, x, y, comp)) return 1; | ||
7331 | #endif | ||
7332 | |||
7333 | #ifndef STBI_NO_HDR | ||
7334 | if (stbi__hdr_info(s, x, y, comp)) return 1; | ||
7335 | #endif | ||
7336 | |||
7337 | // test tga last because it's a crappy test! | ||
7338 | #ifndef STBI_NO_TGA | ||
7339 | if (stbi__tga_info(s, x, y, comp)) | ||
7340 | return 1; | ||
7341 | #endif | ||
7342 | return stbi__err("unknown image type", "Image not of any known type, or corrupt"); | ||
7343 | } | ||
7344 | |||
7345 | static int stbi__is_16_main(stbi__context *s) | ||
7346 | { | ||
7347 | #ifndef STBI_NO_PNG | ||
7348 | if (stbi__png_is16(s)) return 1; | ||
7349 | #endif | ||
7350 | |||
7351 | #ifndef STBI_NO_PSD | ||
7352 | if (stbi__psd_is16(s)) return 1; | ||
7353 | #endif | ||
7354 | |||
7355 | return 0; | ||
7356 | } | ||
7357 | |||
7358 | #ifndef STBI_NO_STDIO | ||
7359 | STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp) | ||
7360 | { | ||
7361 | FILE *f = stbi__fopen(filename, "rb"); | ||
7362 | int result; | ||
7363 | if (!f) return stbi__err("can't fopen", "Unable to open file"); | ||
7364 | result = stbi_info_from_file(f, x, y, comp); | ||
7365 | fclose(f); | ||
7366 | return result; | ||
7367 | } | ||
7368 | |||
7369 | STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp) | ||
7370 | { | ||
7371 | int r; | ||
7372 | stbi__context s; | ||
7373 | long pos = ftell(f); | ||
7374 | stbi__start_file(&s, f); | ||
7375 | r = stbi__info_main(&s,x,y,comp); | ||
7376 | fseek(f,pos,SEEK_SET); | ||
7377 | return r; | ||
7378 | } | ||
7379 | |||
7380 | STBIDEF int stbi_is_16_bit(char const *filename) | ||
7381 | { | ||
7382 | FILE *f = stbi__fopen(filename, "rb"); | ||
7383 | int result; | ||
7384 | if (!f) return stbi__err("can't fopen", "Unable to open file"); | ||
7385 | result = stbi_is_16_bit_from_file(f); | ||
7386 | fclose(f); | ||
7387 | return result; | ||
7388 | } | ||
7389 | |||
7390 | STBIDEF int stbi_is_16_bit_from_file(FILE *f) | ||
7391 | { | ||
7392 | int r; | ||
7393 | stbi__context s; | ||
7394 | long pos = ftell(f); | ||
7395 | stbi__start_file(&s, f); | ||
7396 | r = stbi__is_16_main(&s); | ||
7397 | fseek(f,pos,SEEK_SET); | ||
7398 | return r; | ||
7399 | } | ||
7400 | #endif // !STBI_NO_STDIO | ||
7401 | |||
7402 | STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp) | ||
7403 | { | ||
7404 | stbi__context s; | ||
7405 | stbi__start_mem(&s,buffer,len); | ||
7406 | return stbi__info_main(&s,x,y,comp); | ||
7407 | } | ||
7408 | |||
7409 | STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp) | ||
7410 | { | ||
7411 | stbi__context s; | ||
7412 | stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); | ||
7413 | return stbi__info_main(&s,x,y,comp); | ||
7414 | } | ||
7415 | |||
7416 | STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len) | ||
7417 | { | ||
7418 | stbi__context s; | ||
7419 | stbi__start_mem(&s,buffer,len); | ||
7420 | return stbi__is_16_main(&s); | ||
7421 | } | ||
7422 | |||
7423 | STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user) | ||
7424 | { | ||
7425 | stbi__context s; | ||
7426 | stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); | ||
7427 | return stbi__is_16_main(&s); | ||
7428 | } | ||
7429 | |||
7430 | #endif // STB_IMAGE_IMPLEMENTATION | ||
7431 | |||
7432 | /* | ||
7433 | revision history: | ||
7434 | 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs | ||
7435 | 2.19 (2018-02-11) fix warning | ||
7436 | 2.18 (2018-01-30) fix warnings | ||
7437 | 2.17 (2018-01-29) change sbti__shiftsigned to avoid clang -O2 bug | ||
7438 | 1-bit BMP | ||
7439 | *_is_16_bit api | ||
7440 | avoid warnings | ||
7441 | 2.16 (2017-07-23) all functions have 16-bit variants; | ||
7442 | STBI_NO_STDIO works again; | ||
7443 | compilation fixes; | ||
7444 | fix rounding in unpremultiply; | ||
7445 | optimize vertical flip; | ||
7446 | disable raw_len validation; | ||
7447 | documentation fixes | ||
7448 | 2.15 (2017-03-18) fix png-1,2,4 bug; now all Imagenet JPGs decode; | ||
7449 | warning fixes; disable run-time SSE detection on gcc; | ||
7450 | uniform handling of optional "return" values; | ||
7451 | thread-safe initialization of zlib tables | ||
7452 | 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs | ||
7453 | 2.13 (2016-11-29) add 16-bit API, only supported for PNG right now | ||
7454 | 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes | ||
7455 | 2.11 (2016-04-02) allocate large structures on the stack | ||
7456 | remove white matting for transparent PSD | ||
7457 | fix reported channel count for PNG & BMP | ||
7458 | re-enable SSE2 in non-gcc 64-bit | ||
7459 | support RGB-formatted JPEG | ||
7460 | read 16-bit PNGs (only as 8-bit) | ||
7461 | 2.10 (2016-01-22) avoid warning introduced in 2.09 by STBI_REALLOC_SIZED | ||
7462 | 2.09 (2016-01-16) allow comments in PNM files | ||
7463 | 16-bit-per-pixel TGA (not bit-per-component) | ||
7464 | info() for TGA could break due to .hdr handling | ||
7465 | info() for BMP to shares code instead of sloppy parse | ||
7466 | can use STBI_REALLOC_SIZED if allocator doesn't support realloc | ||
7467 | code cleanup | ||
7468 | 2.08 (2015-09-13) fix to 2.07 cleanup, reading RGB PSD as RGBA | ||
7469 | 2.07 (2015-09-13) fix compiler warnings | ||
7470 | partial animated GIF support | ||
7471 | limited 16-bpc PSD support | ||
7472 | #ifdef unused functions | ||
7473 | bug with < 92 byte PIC,PNM,HDR,TGA | ||
7474 | 2.06 (2015-04-19) fix bug where PSD returns wrong '*comp' value | ||
7475 | 2.05 (2015-04-19) fix bug in progressive JPEG handling, fix warning | ||
7476 | 2.04 (2015-04-15) try to re-enable SIMD on MinGW 64-bit | ||
7477 | 2.03 (2015-04-12) extra corruption checking (mmozeiko) | ||
7478 | stbi_set_flip_vertically_on_load (nguillemot) | ||
7479 | fix NEON support; fix mingw support | ||
7480 | 2.02 (2015-01-19) fix incorrect assert, fix warning | ||
7481 | 2.01 (2015-01-17) fix various warnings; suppress SIMD on gcc 32-bit without -msse2 | ||
7482 | 2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG | ||
7483 | 2.00 (2014-12-25) optimize JPG, including x86 SSE2 & NEON SIMD (ryg) | ||
7484 | progressive JPEG (stb) | ||
7485 | PGM/PPM support (Ken Miller) | ||
7486 | STBI_MALLOC,STBI_REALLOC,STBI_FREE | ||
7487 | GIF bugfix -- seemingly never worked | ||
7488 | STBI_NO_*, STBI_ONLY_* | ||
7489 | 1.48 (2014-12-14) fix incorrectly-named assert() | ||
7490 | 1.47 (2014-12-14) 1/2/4-bit PNG support, both direct and paletted (Omar Cornut & stb) | ||
7491 | optimize PNG (ryg) | ||
7492 | fix bug in interlaced PNG with user-specified channel count (stb) | ||
7493 | 1.46 (2014-08-26) | ||
7494 | fix broken tRNS chunk (colorkey-style transparency) in non-paletted PNG | ||
7495 | 1.45 (2014-08-16) | ||
7496 | fix MSVC-ARM internal compiler error by wrapping malloc | ||
7497 | 1.44 (2014-08-07) | ||
7498 | various warning fixes from Ronny Chevalier | ||
7499 | 1.43 (2014-07-15) | ||
7500 | fix MSVC-only compiler problem in code changed in 1.42 | ||
7501 | 1.42 (2014-07-09) | ||
7502 | don't define _CRT_SECURE_NO_WARNINGS (affects user code) | ||
7503 | fixes to stbi__cleanup_jpeg path | ||
7504 | added STBI_ASSERT to avoid requiring assert.h | ||
7505 | 1.41 (2014-06-25) | ||
7506 | fix search&replace from 1.36 that messed up comments/error messages | ||
7507 | 1.40 (2014-06-22) | ||
7508 | fix gcc struct-initialization warning | ||
7509 | 1.39 (2014-06-15) | ||
7510 | fix to TGA optimization when req_comp != number of components in TGA; | ||
7511 | fix to GIF loading because BMP wasn't rewinding (whoops, no GIFs in my test suite) | ||
7512 | add support for BMP version 5 (more ignored fields) | ||
7513 | 1.38 (2014-06-06) | ||
7514 | suppress MSVC warnings on integer casts truncating values | ||
7515 | fix accidental rename of 'skip' field of I/O | ||
7516 | 1.37 (2014-06-04) | ||
7517 | remove duplicate typedef | ||
7518 | 1.36 (2014-06-03) | ||
7519 | convert to header file single-file library | ||
7520 | if de-iphone isn't set, load iphone images color-swapped instead of returning NULL | ||
7521 | 1.35 (2014-05-27) | ||
7522 | various warnings | ||
7523 | fix broken STBI_SIMD path | ||
7524 | fix bug where stbi_load_from_file no longer left file pointer in correct place | ||
7525 | fix broken non-easy path for 32-bit BMP (possibly never used) | ||
7526 | TGA optimization by Arseny Kapoulkine | ||
7527 | 1.34 (unknown) | ||
7528 | use STBI_NOTUSED in stbi__resample_row_generic(), fix one more leak in tga failure case | ||
7529 | 1.33 (2011-07-14) | ||
7530 | make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly improvements | ||
7531 | 1.32 (2011-07-13) | ||
7532 | support for "info" function for all supported filetypes (SpartanJ) | ||
7533 | 1.31 (2011-06-20) | ||
7534 | a few more leak fixes, bug in PNG handling (SpartanJ) | ||
7535 | 1.30 (2011-06-11) | ||
7536 | added ability to load files via callbacks to accomidate custom input streams (Ben Wenger) | ||
7537 | removed deprecated format-specific test/load functions | ||
7538 | removed support for installable file formats (stbi_loader) -- would have been broken for IO callbacks anyway | ||
7539 | error cases in bmp and tga give messages and don't leak (Raymond Barbiero, grisha) | ||
7540 | fix inefficiency in decoding 32-bit BMP (David Woo) | ||
7541 | 1.29 (2010-08-16) | ||
7542 | various warning fixes from Aurelien Pocheville | ||
7543 | 1.28 (2010-08-01) | ||
7544 | fix bug in GIF palette transparency (SpartanJ) | ||
7545 | 1.27 (2010-08-01) | ||
7546 | cast-to-stbi_uc to fix warnings | ||
7547 | 1.26 (2010-07-24) | ||
7548 | fix bug in file buffering for PNG reported by SpartanJ | ||
7549 | 1.25 (2010-07-17) | ||
7550 | refix trans_data warning (Won Chun) | ||
7551 | 1.24 (2010-07-12) | ||
7552 | perf improvements reading from files on platforms with lock-heavy fgetc() | ||
7553 | minor perf improvements for jpeg | ||
7554 | deprecated type-specific functions so we'll get feedback if they're needed | ||
7555 | attempt to fix trans_data warning (Won Chun) | ||
7556 | 1.23 fixed bug in iPhone support | ||
7557 | 1.22 (2010-07-10) | ||
7558 | removed image *writing* support | ||
7559 | stbi_info support from Jetro Lauha | ||
7560 | GIF support from Jean-Marc Lienher | ||
7561 | iPhone PNG-extensions from James Brown | ||
7562 | warning-fixes from Nicolas Schulz and Janez Zemva (i.stbi__err. Janez (U+017D)emva) | ||
7563 | 1.21 fix use of 'stbi_uc' in header (reported by jon blow) | ||
7564 | 1.20 added support for Softimage PIC, by Tom Seddon | ||
7565 | 1.19 bug in interlaced PNG corruption check (found by ryg) | ||
7566 | 1.18 (2008-08-02) | ||
7567 | fix a threading bug (local mutable static) | ||
7568 | 1.17 support interlaced PNG | ||
7569 | 1.16 major bugfix - stbi__convert_format converted one too many pixels | ||
7570 | 1.15 initialize some fields for thread safety | ||
7571 | 1.14 fix threadsafe conversion bug | ||
7572 | header-file-only version (#define STBI_HEADER_FILE_ONLY before including) | ||
7573 | 1.13 threadsafe | ||
7574 | 1.12 const qualifiers in the API | ||
7575 | 1.11 Support installable IDCT, colorspace conversion routines | ||
7576 | 1.10 Fixes for 64-bit (don't use "unsigned long") | ||
7577 | optimized upsampling by Fabian "ryg" Giesen | ||
7578 | 1.09 Fix format-conversion for PSD code (bad global variables!) | ||
7579 | 1.08 Thatcher Ulrich's PSD code integrated by Nicolas Schulz | ||
7580 | 1.07 attempt to fix C++ warning/errors again | ||
7581 | 1.06 attempt to fix C++ warning/errors again | ||
7582 | 1.05 fix TGA loading to return correct *comp and use good luminance calc | ||
7583 | 1.04 default float alpha is 1, not 255; use 'void *' for stbi_image_free | ||
7584 | 1.03 bugfixes to STBI_NO_STDIO, STBI_NO_HDR | ||
7585 | 1.02 support for (subset of) HDR files, float interface for preferred access to them | ||
7586 | 1.01 fix bug: possible bug in handling right-side up bmps... not sure | ||
7587 | fix bug: the stbi__bmp_load() and stbi__tga_load() functions didn't work at all | ||
7588 | 1.00 interface to zlib that skips zlib header | ||
7589 | 0.99 correct handling of alpha in palette | ||
7590 | 0.98 TGA loader by lonesock; dynamically add loaders (untested) | ||
7591 | 0.97 jpeg errors on too large a file; also catch another malloc failure | ||
7592 | 0.96 fix detection of invalid v value - particleman@mollyrocket forum | ||
7593 | 0.95 during header scan, seek to markers in case of padding | ||
7594 | 0.94 STBI_NO_STDIO to disable stdio usage; rename all #defines the same | ||
7595 | 0.93 handle jpegtran output; verbose errors | ||
7596 | 0.92 read 4,8,16,24,32-bit BMP files of several formats | ||
7597 | 0.91 output 24-bit Windows 3.0 BMP files | ||
7598 | 0.90 fix a few more warnings; bump version number to approach 1.0 | ||
7599 | 0.61 bugfixes due to Marc LeBlanc, Christopher Lloyd | ||
7600 | 0.60 fix compiling as c++ | ||
7601 | 0.59 fix warnings: merge Dave Moore's -Wall fixes | ||
7602 | 0.58 fix bug: zlib uncompressed mode len/nlen was wrong endian | ||
7603 | 0.57 fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available | ||
7604 | 0.56 fix bug: zlib uncompressed mode len vs. nlen | ||
7605 | 0.55 fix bug: restart_interval not initialized to 0 | ||
7606 | 0.54 allow NULL for 'int *comp' | ||
7607 | 0.53 fix bug in png 3->4; speedup png decoding | ||
7608 | 0.52 png handles req_comp=3,4 directly; minor cleanup; jpeg comments | ||
7609 | 0.51 obey req_comp requests, 1-component jpegs return as 1-component, | ||
7610 | on 'test' only check type, not whether we support this variant | ||
7611 | 0.50 (2006-11-19) | ||
7612 | first released version | ||
7613 | */ | ||
7614 | |||
7615 | |||
7616 | /* | ||
7617 | ------------------------------------------------------------------------------ | ||
7618 | This software is available under 2 licenses -- choose whichever you prefer. | ||
7619 | ------------------------------------------------------------------------------ | ||
7620 | ALTERNATIVE A - MIT License | ||
7621 | Copyright (c) 2017 Sean Barrett | ||
7622 | Permission is hereby granted, free of charge, to any person obtaining a copy of | ||
7623 | this software and associated documentation files (the "Software"), to deal in | ||
7624 | the Software without restriction, including without limitation the rights to | ||
7625 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies | ||
7626 | of the Software, and to permit persons to whom the Software is furnished to do | ||
7627 | so, subject to the following conditions: | ||
7628 | The above copyright notice and this permission notice shall be included in all | ||
7629 | copies or substantial portions of the Software. | ||
7630 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
7631 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
7632 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | ||
7633 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | ||
7634 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | ||
7635 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | ||
7636 | SOFTWARE. | ||
7637 | ------------------------------------------------------------------------------ | ||
7638 | ALTERNATIVE B - Public Domain (www.unlicense.org) | ||
7639 | This is free and unencumbered software released into the public domain. | ||
7640 | Anyone is free to copy, modify, publish, use, compile, sell, or distribute this | ||
7641 | software, either in source code form or as a compiled binary, for any purpose, | ||
7642 | commercial or non-commercial, and by any means. | ||
7643 | In jurisdictions that recognize copyright laws, the author or authors of this | ||
7644 | software dedicate any and all copyright interest in the software to the public | ||
7645 | domain. We make this dedication for the benefit of the public at large and to | ||
7646 | the detriment of our heirs and successors. We intend this dedication to be an | ||
7647 | overt act of relinquishment in perpetuity of all present and future rights to | ||
7648 | this software under copyright law. | ||
7649 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
7650 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
7651 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | ||
7652 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | ||
7653 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | ||
7654 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | ||
7655 | ------------------------------------------------------------------------------ | ||
7656 | */ | ||
diff --git a/src/stb_truetype.h b/src/stb_truetype.h new file mode 100644 index 00000000..935a6de2 --- /dev/null +++ b/src/stb_truetype.h | |||
@@ -0,0 +1,5011 @@ | |||
1 | // stb_truetype.h - v1.24 - public domain | ||
2 | // authored from 2009-2020 by Sean Barrett / RAD Game Tools | ||
3 | // | ||
4 | // ======================================================================= | ||
5 | // | ||
6 | // NO SECURITY GUARANTEE -- DO NOT USE THIS ON UNTRUSTED FONT FILES | ||
7 | // | ||
8 | // This library does no range checking of the offsets found in the file, | ||
9 | // meaning an attacker can use it to read arbitrary memory. | ||
10 | // | ||
11 | // ======================================================================= | ||
12 | // | ||
13 | // This library processes TrueType files: | ||
14 | // parse files | ||
15 | // extract glyph metrics | ||
16 | // extract glyph shapes | ||
17 | // render glyphs to one-channel bitmaps with antialiasing (box filter) | ||
18 | // render glyphs to one-channel SDF bitmaps (signed-distance field/function) | ||
19 | // | ||
20 | // Todo: | ||
21 | // non-MS cmaps | ||
22 | // crashproof on bad data | ||
23 | // hinting? (no longer patented) | ||
24 | // cleartype-style AA? | ||
25 | // optimize: use simple memory allocator for intermediates | ||
26 | // optimize: build edge-list directly from curves | ||
27 | // optimize: rasterize directly from curves? | ||
28 | // | ||
29 | // ADDITIONAL CONTRIBUTORS | ||
30 | // | ||
31 | // Mikko Mononen: compound shape support, more cmap formats | ||
32 | // Tor Andersson: kerning, subpixel rendering | ||
33 | // Dougall Johnson: OpenType / Type 2 font handling | ||
34 | // Daniel Ribeiro Maciel: basic GPOS-based kerning | ||
35 | // | ||
36 | // Misc other: | ||
37 | // Ryan Gordon | ||
38 | // Simon Glass | ||
39 | // github:IntellectualKitty | ||
40 | // Imanol Celaya | ||
41 | // Daniel Ribeiro Maciel | ||
42 | // | ||
43 | // Bug/warning reports/fixes: | ||
44 | // "Zer" on mollyrocket Fabian "ryg" Giesen github:NiLuJe | ||
45 | // Cass Everitt Martins Mozeiko github:aloucks | ||
46 | // stoiko (Haemimont Games) Cap Petschulat github:oyvindjam | ||
47 | // Brian Hook Omar Cornut github:vassvik | ||
48 | // Walter van Niftrik Ryan Griege | ||
49 | // David Gow Peter LaValle | ||
50 | // David Given Sergey Popov | ||
51 | // Ivan-Assen Ivanov Giumo X. Clanjor | ||
52 | // Anthony Pesch Higor Euripedes | ||
53 | // Johan Duparc Thomas Fields | ||
54 | // Hou Qiming Derek Vinyard | ||
55 | // Rob Loach Cort Stratton | ||
56 | // Kenney Phillis Jr. Brian Costabile | ||
57 | // Ken Voskuil (kaesve) | ||
58 | // | ||
59 | // VERSION HISTORY | ||
60 | // | ||
61 | // 1.24 (2020-02-05) fix warning | ||
62 | // 1.23 (2020-02-02) query SVG data for glyphs; query whole kerning table (but only kern not GPOS) | ||
63 | // 1.22 (2019-08-11) minimize missing-glyph duplication; fix kerning if both 'GPOS' and 'kern' are defined | ||
64 | // 1.21 (2019-02-25) fix warning | ||
65 | // 1.20 (2019-02-07) PackFontRange skips missing codepoints; GetScaleFontVMetrics() | ||
66 | // 1.19 (2018-02-11) GPOS kerning, STBTT_fmod | ||
67 | // 1.18 (2018-01-29) add missing function | ||
68 | // 1.17 (2017-07-23) make more arguments const; doc fix | ||
69 | // 1.16 (2017-07-12) SDF support | ||
70 | // 1.15 (2017-03-03) make more arguments const | ||
71 | // 1.14 (2017-01-16) num-fonts-in-TTC function | ||
72 | // 1.13 (2017-01-02) support OpenType fonts, certain Apple fonts | ||
73 | // 1.12 (2016-10-25) suppress warnings about casting away const with -Wcast-qual | ||
74 | // 1.11 (2016-04-02) fix unused-variable warning | ||
75 | // 1.10 (2016-04-02) user-defined fabs(); rare memory leak; remove duplicate typedef | ||
76 | // 1.09 (2016-01-16) warning fix; avoid crash on outofmem; use allocation userdata properly | ||
77 | // 1.08 (2015-09-13) document stbtt_Rasterize(); fixes for vertical & horizontal edges | ||
78 | // 1.07 (2015-08-01) allow PackFontRanges to accept arrays of sparse codepoints; | ||
79 | // variant PackFontRanges to pack and render in separate phases; | ||
80 | // fix stbtt_GetFontOFfsetForIndex (never worked for non-0 input?); | ||
81 | // fixed an assert() bug in the new rasterizer | ||
82 | // replace assert() with STBTT_assert() in new rasterizer | ||
83 | // | ||
84 | // Full history can be found at the end of this file. | ||
85 | // | ||
86 | // LICENSE | ||
87 | // | ||
88 | // See end of file for license information. | ||
89 | // | ||
90 | // USAGE | ||
91 | // | ||
92 | // Include this file in whatever places need to refer to it. In ONE C/C++ | ||
93 | // file, write: | ||
94 | // #define STB_TRUETYPE_IMPLEMENTATION | ||
95 | // before the #include of this file. This expands out the actual | ||
96 | // implementation into that C/C++ file. | ||
97 | // | ||
98 | // To make the implementation private to the file that generates the implementation, | ||
99 | // #define STBTT_STATIC | ||
100 | // | ||
101 | // Simple 3D API (don't ship this, but it's fine for tools and quick start) | ||
102 | // stbtt_BakeFontBitmap() -- bake a font to a bitmap for use as texture | ||
103 | // stbtt_GetBakedQuad() -- compute quad to draw for a given char | ||
104 | // | ||
105 | // Improved 3D API (more shippable): | ||
106 | // #include "stb_rect_pack.h" -- optional, but you really want it | ||
107 | // stbtt_PackBegin() | ||
108 | // stbtt_PackSetOversampling() -- for improved quality on small fonts | ||
109 | // stbtt_PackFontRanges() -- pack and renders | ||
110 | // stbtt_PackEnd() | ||
111 | // stbtt_GetPackedQuad() | ||
112 | // | ||
113 | // "Load" a font file from a memory buffer (you have to keep the buffer loaded) | ||
114 | // stbtt_InitFont() | ||
115 | // stbtt_GetFontOffsetForIndex() -- indexing for TTC font collections | ||
116 | // stbtt_GetNumberOfFonts() -- number of fonts for TTC font collections | ||
117 | // | ||
118 | // Render a unicode codepoint to a bitmap | ||
119 | // stbtt_GetCodepointBitmap() -- allocates and returns a bitmap | ||
120 | // stbtt_MakeCodepointBitmap() -- renders into bitmap you provide | ||
121 | // stbtt_GetCodepointBitmapBox() -- how big the bitmap must be | ||
122 | // | ||
123 | // Character advance/positioning | ||
124 | // stbtt_GetCodepointHMetrics() | ||
125 | // stbtt_GetFontVMetrics() | ||
126 | // stbtt_GetFontVMetricsOS2() | ||
127 | // stbtt_GetCodepointKernAdvance() | ||
128 | // | ||
129 | // Starting with version 1.06, the rasterizer was replaced with a new, | ||
130 | // faster and generally-more-precise rasterizer. The new rasterizer more | ||
131 | // accurately measures pixel coverage for anti-aliasing, except in the case | ||
132 | // where multiple shapes overlap, in which case it overestimates the AA pixel | ||
133 | // coverage. Thus, anti-aliasing of intersecting shapes may look wrong. If | ||
134 | // this turns out to be a problem, you can re-enable the old rasterizer with | ||
135 | // #define STBTT_RASTERIZER_VERSION 1 | ||
136 | // which will incur about a 15% speed hit. | ||
137 | // | ||
138 | // ADDITIONAL DOCUMENTATION | ||
139 | // | ||
140 | // Immediately after this block comment are a series of sample programs. | ||
141 | // | ||
142 | // After the sample programs is the "header file" section. This section | ||
143 | // includes documentation for each API function. | ||
144 | // | ||
145 | // Some important concepts to understand to use this library: | ||
146 | // | ||
147 | // Codepoint | ||
148 | // Characters are defined by unicode codepoints, e.g. 65 is | ||
149 | // uppercase A, 231 is lowercase c with a cedilla, 0x7e30 is | ||
150 | // the hiragana for "ma". | ||
151 | // | ||
152 | // Glyph | ||
153 | // A visual character shape (every codepoint is rendered as | ||
154 | // some glyph) | ||
155 | // | ||
156 | // Glyph index | ||
157 | // A font-specific integer ID representing a glyph | ||
158 | // | ||
159 | // Baseline | ||
160 | // Glyph shapes are defined relative to a baseline, which is the | ||
161 | // bottom of uppercase characters. Characters extend both above | ||
162 | // and below the baseline. | ||
163 | // | ||
164 | // Current Point | ||
165 | // As you draw text to the screen, you keep track of a "current point" | ||
166 | // which is the origin of each character. The current point's vertical | ||
167 | // position is the baseline. Even "baked fonts" use this model. | ||
168 | // | ||
169 | // Vertical Font Metrics | ||
170 | // The vertical qualities of the font, used to vertically position | ||
171 | // and space the characters. See docs for stbtt_GetFontVMetrics. | ||
172 | // | ||
173 | // Font Size in Pixels or Points | ||
174 | // The preferred interface for specifying font sizes in stb_truetype | ||
175 | // is to specify how tall the font's vertical extent should be in pixels. | ||
176 | // If that sounds good enough, skip the next paragraph. | ||
177 | // | ||
178 | // Most font APIs instead use "points", which are a common typographic | ||
179 | // measurement for describing font size, defined as 72 points per inch. | ||
180 | // stb_truetype provides a point API for compatibility. However, true | ||
181 | // "per inch" conventions don't make much sense on computer displays | ||
182 | // since different monitors have different number of pixels per | ||
183 | // inch. For example, Windows traditionally uses a convention that | ||
184 | // there are 96 pixels per inch, thus making 'inch' measurements have | ||
185 | // nothing to do with inches, and thus effectively defining a point to | ||
186 | // be 1.333 pixels. Additionally, the TrueType font data provides | ||
187 | // an explicit scale factor to scale a given font's glyphs to points, | ||
188 | // but the author has observed that this scale factor is often wrong | ||
189 | // for non-commercial fonts, thus making fonts scaled in points | ||
190 | // according to the TrueType spec incoherently sized in practice. | ||
191 | // | ||
192 | // DETAILED USAGE: | ||
193 | // | ||
194 | // Scale: | ||
195 | // Select how high you want the font to be, in points or pixels. | ||
196 | // Call ScaleForPixelHeight or ScaleForMappingEmToPixels to compute | ||
197 | // a scale factor SF that will be used by all other functions. | ||
198 | // | ||
199 | // Baseline: | ||
200 | // You need to select a y-coordinate that is the baseline of where | ||
201 | // your text will appear. Call GetFontBoundingBox to get the baseline-relative | ||
202 | // bounding box for all characters. SF*-y0 will be the distance in pixels | ||
203 | // that the worst-case character could extend above the baseline, so if | ||
204 | // you want the top edge of characters to appear at the top of the | ||
205 | // screen where y=0, then you would set the baseline to SF*-y0. | ||
206 | // | ||
207 | // Current point: | ||
208 | // Set the current point where the first character will appear. The | ||
209 | // first character could extend left of the current point; this is font | ||
210 | // dependent. You can either choose a current point that is the leftmost | ||
211 | // point and hope, or add some padding, or check the bounding box or | ||
212 | // left-side-bearing of the first character to be displayed and set | ||
213 | // the current point based on that. | ||
214 | // | ||
215 | // Displaying a character: | ||
216 | // Compute the bounding box of the character. It will contain signed values | ||
217 | // relative to <current_point, baseline>. I.e. if it returns x0,y0,x1,y1, | ||
218 | // then the character should be displayed in the rectangle from | ||
219 | // <current_point+SF*x0, baseline+SF*y0> to <current_point+SF*x1,baseline+SF*y1). | ||
220 | // | ||
221 | // Advancing for the next character: | ||
222 | // Call GlyphHMetrics, and compute 'current_point += SF * advance'. | ||
223 | // | ||
224 | // | ||
225 | // ADVANCED USAGE | ||
226 | // | ||
227 | // Quality: | ||
228 | // | ||
229 | // - Use the functions with Subpixel at the end to allow your characters | ||
230 | // to have subpixel positioning. Since the font is anti-aliased, not | ||
231 | // hinted, this is very import for quality. (This is not possible with | ||
232 | // baked fonts.) | ||
233 | // | ||
234 | // - Kerning is now supported, and if you're supporting subpixel rendering | ||
235 | // then kerning is worth using to give your text a polished look. | ||
236 | // | ||
237 | // Performance: | ||
238 | // | ||
239 | // - Convert Unicode codepoints to glyph indexes and operate on the glyphs; | ||
240 | // if you don't do this, stb_truetype is forced to do the conversion on | ||
241 | // every call. | ||
242 | // | ||
243 | // - There are a lot of memory allocations. We should modify it to take | ||
244 | // a temp buffer and allocate from the temp buffer (without freeing), | ||
245 | // should help performance a lot. | ||
246 | // | ||
247 | // NOTES | ||
248 | // | ||
249 | // The system uses the raw data found in the .ttf file without changing it | ||
250 | // and without building auxiliary data structures. This is a bit inefficient | ||
251 | // on little-endian systems (the data is big-endian), but assuming you're | ||
252 | // caching the bitmaps or glyph shapes this shouldn't be a big deal. | ||
253 | // | ||
254 | // It appears to be very hard to programmatically determine what font a | ||
255 | // given file is in a general way. I provide an API for this, but I don't | ||
256 | // recommend it. | ||
257 | // | ||
258 | // | ||
259 | // PERFORMANCE MEASUREMENTS FOR 1.06: | ||
260 | // | ||
261 | // 32-bit 64-bit | ||
262 | // Previous release: 8.83 s 7.68 s | ||
263 | // Pool allocations: 7.72 s 6.34 s | ||
264 | // Inline sort : 6.54 s 5.65 s | ||
265 | // New rasterizer : 5.63 s 5.00 s | ||
266 | |||
267 | ////////////////////////////////////////////////////////////////////////////// | ||
268 | ////////////////////////////////////////////////////////////////////////////// | ||
269 | //// | ||
270 | //// SAMPLE PROGRAMS | ||
271 | //// | ||
272 | // | ||
273 | // Incomplete text-in-3d-api example, which draws quads properly aligned to be lossless | ||
274 | // | ||
275 | #if 0 | ||
276 | #define STB_TRUETYPE_IMPLEMENTATION // force following include to generate implementation | ||
277 | #include "stb_truetype.h" | ||
278 | |||
279 | unsigned char ttf_buffer[1<<20]; | ||
280 | unsigned char temp_bitmap[512*512]; | ||
281 | |||
282 | stbtt_bakedchar cdata[96]; // ASCII 32..126 is 95 glyphs | ||
283 | GLuint ftex; | ||
284 | |||
285 | void my_stbtt_initfont(void) | ||
286 | { | ||
287 | fread(ttf_buffer, 1, 1<<20, fopen("c:/windows/fonts/times.ttf", "rb")); | ||
288 | stbtt_BakeFontBitmap(ttf_buffer,0, 32.0, temp_bitmap,512,512, 32,96, cdata); // no guarantee this fits! | ||
289 | // can free ttf_buffer at this point | ||
290 | glGenTextures(1, &ftex); | ||
291 | glBindTexture(GL_TEXTURE_2D, ftex); | ||
292 | glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, 512,512, 0, GL_ALPHA, GL_UNSIGNED_BYTE, temp_bitmap); | ||
293 | // can free temp_bitmap at this point | ||
294 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); | ||
295 | } | ||
296 | |||
297 | void my_stbtt_print(float x, float y, char *text) | ||
298 | { | ||
299 | // assume orthographic projection with units = screen pixels, origin at top left | ||
300 | glEnable(GL_TEXTURE_2D); | ||
301 | glBindTexture(GL_TEXTURE_2D, ftex); | ||
302 | glBegin(GL_QUADS); | ||
303 | while (*text) { | ||
304 | if (*text >= 32 && *text < 128) { | ||
305 | stbtt_aligned_quad q; | ||
306 | stbtt_GetBakedQuad(cdata, 512,512, *text-32, &x,&y,&q,1);//1=opengl & d3d10+,0=d3d9 | ||
307 | glTexCoord2f(q.s0,q.t1); glVertex2f(q.x0,q.y0); | ||
308 | glTexCoord2f(q.s1,q.t1); glVertex2f(q.x1,q.y0); | ||
309 | glTexCoord2f(q.s1,q.t0); glVertex2f(q.x1,q.y1); | ||
310 | glTexCoord2f(q.s0,q.t0); glVertex2f(q.x0,q.y1); | ||
311 | } | ||
312 | ++text; | ||
313 | } | ||
314 | glEnd(); | ||
315 | } | ||
316 | #endif | ||
317 | // | ||
318 | // | ||
319 | ////////////////////////////////////////////////////////////////////////////// | ||
320 | // | ||
321 | // Complete program (this compiles): get a single bitmap, print as ASCII art | ||
322 | // | ||
323 | #if 0 | ||
324 | #include <stdio.h> | ||
325 | #define STB_TRUETYPE_IMPLEMENTATION // force following include to generate implementation | ||
326 | #include "stb_truetype.h" | ||
327 | |||
328 | char ttf_buffer[1<<25]; | ||
329 | |||
330 | int main(int argc, char **argv) | ||
331 | { | ||
332 | stbtt_fontinfo font; | ||
333 | unsigned char *bitmap; | ||
334 | int w,h,i,j,c = (argc > 1 ? atoi(argv[1]) : 'a'), s = (argc > 2 ? atoi(argv[2]) : 20); | ||
335 | |||
336 | fread(ttf_buffer, 1, 1<<25, fopen(argc > 3 ? argv[3] : "c:/windows/fonts/arialbd.ttf", "rb")); | ||
337 | |||
338 | stbtt_InitFont(&font, ttf_buffer, stbtt_GetFontOffsetForIndex(ttf_buffer,0)); | ||
339 | bitmap = stbtt_GetCodepointBitmap(&font, 0,stbtt_ScaleForPixelHeight(&font, s), c, &w, &h, 0,0); | ||
340 | |||
341 | for (j=0; j < h; ++j) { | ||
342 | for (i=0; i < w; ++i) | ||
343 | putchar(" .:ioVM@"[bitmap[j*w+i]>>5]); | ||
344 | putchar('\n'); | ||
345 | } | ||
346 | return 0; | ||
347 | } | ||
348 | #endif | ||
349 | // | ||
350 | // Output: | ||
351 | // | ||
352 | // .ii. | ||
353 | // @@@@@@. | ||
354 | // V@Mio@@o | ||
355 | // :i. V@V | ||
356 | // :oM@@M | ||
357 | // :@@@MM@M | ||
358 | // @@o o@M | ||
359 | // :@@. M@M | ||
360 | // @@@o@@@@ | ||
361 | // :M@@V:@@. | ||
362 | // | ||
363 | ////////////////////////////////////////////////////////////////////////////// | ||
364 | // | ||
365 | // Complete program: print "Hello World!" banner, with bugs | ||
366 | // | ||
367 | #if 0 | ||
368 | char buffer[24<<20]; | ||
369 | unsigned char screen[20][79]; | ||
370 | |||
371 | int main(int arg, char **argv) | ||
372 | { | ||
373 | stbtt_fontinfo font; | ||
374 | int i,j,ascent,baseline,ch=0; | ||
375 | float scale, xpos=2; // leave a little padding in case the character extends left | ||
376 | char *text = "Heljo World!"; // intentionally misspelled to show 'lj' brokenness | ||
377 | |||
378 | fread(buffer, 1, 1000000, fopen("c:/windows/fonts/arialbd.ttf", "rb")); | ||
379 | stbtt_InitFont(&font, buffer, 0); | ||
380 | |||
381 | scale = stbtt_ScaleForPixelHeight(&font, 15); | ||
382 | stbtt_GetFontVMetrics(&font, &ascent,0,0); | ||
383 | baseline = (int) (ascent*scale); | ||
384 | |||
385 | while (text[ch]) { | ||
386 | int advance,lsb,x0,y0,x1,y1; | ||
387 | float x_shift = xpos - (float) floor(xpos); | ||
388 | stbtt_GetCodepointHMetrics(&font, text[ch], &advance, &lsb); | ||
389 | stbtt_GetCodepointBitmapBoxSubpixel(&font, text[ch], scale,scale,x_shift,0, &x0,&y0,&x1,&y1); | ||
390 | stbtt_MakeCodepointBitmapSubpixel(&font, &screen[baseline + y0][(int) xpos + x0], x1-x0,y1-y0, 79, scale,scale,x_shift,0, text[ch]); | ||
391 | // note that this stomps the old data, so where character boxes overlap (e.g. 'lj') it's wrong | ||
392 | // because this API is really for baking character bitmaps into textures. if you want to render | ||
393 | // a sequence of characters, you really need to render each bitmap to a temp buffer, then | ||
394 | // "alpha blend" that into the working buffer | ||
395 | xpos += (advance * scale); | ||
396 | if (text[ch+1]) | ||
397 | xpos += scale*stbtt_GetCodepointKernAdvance(&font, text[ch],text[ch+1]); | ||
398 | ++ch; | ||
399 | } | ||
400 | |||
401 | for (j=0; j < 20; ++j) { | ||
402 | for (i=0; i < 78; ++i) | ||
403 | putchar(" .:ioVM@"[screen[j][i]>>5]); | ||
404 | putchar('\n'); | ||
405 | } | ||
406 | |||
407 | return 0; | ||
408 | } | ||
409 | #endif | ||
410 | |||
411 | |||
412 | ////////////////////////////////////////////////////////////////////////////// | ||
413 | ////////////////////////////////////////////////////////////////////////////// | ||
414 | //// | ||
415 | //// INTEGRATION WITH YOUR CODEBASE | ||
416 | //// | ||
417 | //// The following sections allow you to supply alternate definitions | ||
418 | //// of C library functions used by stb_truetype, e.g. if you don't | ||
419 | //// link with the C runtime library. | ||
420 | |||
421 | #ifdef STB_TRUETYPE_IMPLEMENTATION | ||
422 | // #define your own (u)stbtt_int8/16/32 before including to override this | ||
423 | #ifndef stbtt_uint8 | ||
424 | typedef unsigned char stbtt_uint8; | ||
425 | typedef signed char stbtt_int8; | ||
426 | typedef unsigned short stbtt_uint16; | ||
427 | typedef signed short stbtt_int16; | ||
428 | typedef unsigned int stbtt_uint32; | ||
429 | typedef signed int stbtt_int32; | ||
430 | #endif | ||
431 | |||
432 | typedef char stbtt__check_size32[sizeof(stbtt_int32)==4 ? 1 : -1]; | ||
433 | typedef char stbtt__check_size16[sizeof(stbtt_int16)==2 ? 1 : -1]; | ||
434 | |||
435 | // e.g. #define your own STBTT_ifloor/STBTT_iceil() to avoid math.h | ||
436 | #ifndef STBTT_ifloor | ||
437 | #include <math.h> | ||
438 | #define STBTT_ifloor(x) ((int) floor(x)) | ||
439 | #define STBTT_iceil(x) ((int) ceil(x)) | ||
440 | #endif | ||
441 | |||
442 | #ifndef STBTT_sqrt | ||
443 | #include <math.h> | ||
444 | #define STBTT_sqrt(x) sqrt(x) | ||
445 | #define STBTT_pow(x,y) pow(x,y) | ||
446 | #endif | ||
447 | |||
448 | #ifndef STBTT_fmod | ||
449 | #include <math.h> | ||
450 | #define STBTT_fmod(x,y) fmod(x,y) | ||
451 | #endif | ||
452 | |||
453 | #ifndef STBTT_cos | ||
454 | #include <math.h> | ||
455 | #define STBTT_cos(x) cos(x) | ||
456 | #define STBTT_acos(x) acos(x) | ||
457 | #endif | ||
458 | |||
459 | #ifndef STBTT_fabs | ||
460 | #include <math.h> | ||
461 | #define STBTT_fabs(x) fabs(x) | ||
462 | #endif | ||
463 | |||
464 | // #define your own functions "STBTT_malloc" / "STBTT_free" to avoid malloc.h | ||
465 | #ifndef STBTT_malloc | ||
466 | #include <stdlib.h> | ||
467 | #define STBTT_malloc(x,u) ((void)(u),malloc(x)) | ||
468 | #define STBTT_free(x,u) ((void)(u),free(x)) | ||
469 | #endif | ||
470 | |||
471 | #ifndef STBTT_assert | ||
472 | #include <assert.h> | ||
473 | #define STBTT_assert(x) assert(x) | ||
474 | #endif | ||
475 | |||
476 | #ifndef STBTT_strlen | ||
477 | #include <string.h> | ||
478 | #define STBTT_strlen(x) strlen(x) | ||
479 | #endif | ||
480 | |||
481 | #ifndef STBTT_memcpy | ||
482 | #include <string.h> | ||
483 | #define STBTT_memcpy memcpy | ||
484 | #define STBTT_memset memset | ||
485 | #endif | ||
486 | #endif | ||
487 | |||
488 | /////////////////////////////////////////////////////////////////////////////// | ||
489 | /////////////////////////////////////////////////////////////////////////////// | ||
490 | //// | ||
491 | //// INTERFACE | ||
492 | //// | ||
493 | //// | ||
494 | |||
495 | #ifndef __STB_INCLUDE_STB_TRUETYPE_H__ | ||
496 | #define __STB_INCLUDE_STB_TRUETYPE_H__ | ||
497 | |||
498 | #ifdef STBTT_STATIC | ||
499 | #define STBTT_DEF static | ||
500 | #else | ||
501 | #define STBTT_DEF extern | ||
502 | #endif | ||
503 | |||
504 | #ifdef __cplusplus | ||
505 | extern "C" { | ||
506 | #endif | ||
507 | |||
508 | // private structure | ||
509 | typedef struct | ||
510 | { | ||
511 | unsigned char *data; | ||
512 | int cursor; | ||
513 | int size; | ||
514 | } stbtt__buf; | ||
515 | |||
516 | ////////////////////////////////////////////////////////////////////////////// | ||
517 | // | ||
518 | // TEXTURE BAKING API | ||
519 | // | ||
520 | // If you use this API, you only have to call two functions ever. | ||
521 | // | ||
522 | |||
523 | typedef struct | ||
524 | { | ||
525 | unsigned short x0,y0,x1,y1; // coordinates of bbox in bitmap | ||
526 | float xoff,yoff,xadvance; | ||
527 | } stbtt_bakedchar; | ||
528 | |||
529 | STBTT_DEF int stbtt_BakeFontBitmap(const unsigned char *data, int offset, // font location (use offset=0 for plain .ttf) | ||
530 | float pixel_height, // height of font in pixels | ||
531 | unsigned char *pixels, int pw, int ph, // bitmap to be filled in | ||
532 | int first_char, int num_chars, // characters to bake | ||
533 | stbtt_bakedchar *chardata); // you allocate this, it's num_chars long | ||
534 | // if return is positive, the first unused row of the bitmap | ||
535 | // if return is negative, returns the negative of the number of characters that fit | ||
536 | // if return is 0, no characters fit and no rows were used | ||
537 | // This uses a very crappy packing. | ||
538 | |||
539 | typedef struct | ||
540 | { | ||
541 | float x0,y0,s0,t0; // top-left | ||
542 | float x1,y1,s1,t1; // bottom-right | ||
543 | } stbtt_aligned_quad; | ||
544 | |||
545 | STBTT_DEF void stbtt_GetBakedQuad(const stbtt_bakedchar *chardata, int pw, int ph, // same data as above | ||
546 | int char_index, // character to display | ||
547 | float *xpos, float *ypos, // pointers to current position in screen pixel space | ||
548 | stbtt_aligned_quad *q, // output: quad to draw | ||
549 | int opengl_fillrule); // true if opengl fill rule; false if DX9 or earlier | ||
550 | // Call GetBakedQuad with char_index = 'character - first_char', and it | ||
551 | // creates the quad you need to draw and advances the current position. | ||
552 | // | ||
553 | // The coordinate system used assumes y increases downwards. | ||
554 | // | ||
555 | // Characters will extend both above and below the current position; | ||
556 | // see discussion of "BASELINE" above. | ||
557 | // | ||
558 | // It's inefficient; you might want to c&p it and optimize it. | ||
559 | |||
560 | STBTT_DEF void stbtt_GetScaledFontVMetrics(const unsigned char *fontdata, int index, float size, float *ascent, float *descent, float *lineGap); | ||
561 | // Query the font vertical metrics without having to create a font first. | ||
562 | |||
563 | |||
564 | ////////////////////////////////////////////////////////////////////////////// | ||
565 | // | ||
566 | // NEW TEXTURE BAKING API | ||
567 | // | ||
568 | // This provides options for packing multiple fonts into one atlas, not | ||
569 | // perfectly but better than nothing. | ||
570 | |||
571 | typedef struct | ||
572 | { | ||
573 | unsigned short x0,y0,x1,y1; // coordinates of bbox in bitmap | ||
574 | float xoff,yoff,xadvance; | ||
575 | float xoff2,yoff2; | ||
576 | } stbtt_packedchar; | ||
577 | |||
578 | typedef struct stbtt_pack_context stbtt_pack_context; | ||
579 | typedef struct stbtt_fontinfo stbtt_fontinfo; | ||
580 | #ifndef STB_RECT_PACK_VERSION | ||
581 | typedef struct stbrp_rect stbrp_rect; | ||
582 | #endif | ||
583 | |||
584 | STBTT_DEF int stbtt_PackBegin(stbtt_pack_context *spc, unsigned char *pixels, int width, int height, int stride_in_bytes, int padding, void *alloc_context); | ||
585 | // Initializes a packing context stored in the passed-in stbtt_pack_context. | ||
586 | // Future calls using this context will pack characters into the bitmap passed | ||
587 | // in here: a 1-channel bitmap that is width * height. stride_in_bytes is | ||
588 | // the distance from one row to the next (or 0 to mean they are packed tightly | ||
589 | // together). "padding" is the amount of padding to leave between each | ||
590 | // character (normally you want '1' for bitmaps you'll use as textures with | ||
591 | // bilinear filtering). | ||
592 | // | ||
593 | // Returns 0 on failure, 1 on success. | ||
594 | |||
595 | STBTT_DEF void stbtt_PackEnd (stbtt_pack_context *spc); | ||
596 | // Cleans up the packing context and frees all memory. | ||
597 | |||
598 | #define STBTT_POINT_SIZE(x) (-(x)) | ||
599 | |||
600 | STBTT_DEF int stbtt_PackFontRange(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, float font_size, | ||
601 | int first_unicode_char_in_range, int num_chars_in_range, stbtt_packedchar *chardata_for_range); | ||
602 | // Creates character bitmaps from the font_index'th font found in fontdata (use | ||
603 | // font_index=0 if you don't know what that is). It creates num_chars_in_range | ||
604 | // bitmaps for characters with unicode values starting at first_unicode_char_in_range | ||
605 | // and increasing. Data for how to render them is stored in chardata_for_range; | ||
606 | // pass these to stbtt_GetPackedQuad to get back renderable quads. | ||
607 | // | ||
608 | // font_size is the full height of the character from ascender to descender, | ||
609 | // as computed by stbtt_ScaleForPixelHeight. To use a point size as computed | ||
610 | // by stbtt_ScaleForMappingEmToPixels, wrap the point size in STBTT_POINT_SIZE() | ||
611 | // and pass that result as 'font_size': | ||
612 | // ..., 20 , ... // font max minus min y is 20 pixels tall | ||
613 | // ..., STBTT_POINT_SIZE(20), ... // 'M' is 20 pixels tall | ||
614 | |||
615 | typedef struct | ||
616 | { | ||
617 | float font_size; | ||
618 | int first_unicode_codepoint_in_range; // if non-zero, then the chars are continuous, and this is the first codepoint | ||
619 | int *array_of_unicode_codepoints; // if non-zero, then this is an array of unicode codepoints | ||
620 | int num_chars; | ||
621 | stbtt_packedchar *chardata_for_range; // output | ||
622 | unsigned char h_oversample, v_oversample; // don't set these, they're used internally | ||
623 | } stbtt_pack_range; | ||
624 | |||
625 | STBTT_DEF int stbtt_PackFontRanges(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, stbtt_pack_range *ranges, int num_ranges); | ||
626 | // Creates character bitmaps from multiple ranges of characters stored in | ||
627 | // ranges. This will usually create a better-packed bitmap than multiple | ||
628 | // calls to stbtt_PackFontRange. Note that you can call this multiple | ||
629 | // times within a single PackBegin/PackEnd. | ||
630 | |||
631 | STBTT_DEF void stbtt_PackSetOversampling(stbtt_pack_context *spc, unsigned int h_oversample, unsigned int v_oversample); | ||
632 | // Oversampling a font increases the quality by allowing higher-quality subpixel | ||
633 | // positioning, and is especially valuable at smaller text sizes. | ||
634 | // | ||
635 | // This function sets the amount of oversampling for all following calls to | ||
636 | // stbtt_PackFontRange(s) or stbtt_PackFontRangesGatherRects for a given | ||
637 | // pack context. The default (no oversampling) is achieved by h_oversample=1 | ||
638 | // and v_oversample=1. The total number of pixels required is | ||
639 | // h_oversample*v_oversample larger than the default; for example, 2x2 | ||
640 | // oversampling requires 4x the storage of 1x1. For best results, render | ||
641 | // oversampled textures with bilinear filtering. Look at the readme in | ||
642 | // stb/tests/oversample for information about oversampled fonts | ||
643 | // | ||
644 | // To use with PackFontRangesGather etc., you must set it before calls | ||
645 | // call to PackFontRangesGatherRects. | ||
646 | |||
647 | STBTT_DEF void stbtt_PackSetSkipMissingCodepoints(stbtt_pack_context *spc, int skip); | ||
648 | // If skip != 0, this tells stb_truetype to skip any codepoints for which | ||
649 | // there is no corresponding glyph. If skip=0, which is the default, then | ||
650 | // codepoints without a glyph recived the font's "missing character" glyph, | ||
651 | // typically an empty box by convention. | ||
652 | |||
653 | STBTT_DEF void stbtt_GetPackedQuad(const stbtt_packedchar *chardata, int pw, int ph, // same data as above | ||
654 | int char_index, // character to display | ||
655 | float *xpos, float *ypos, // pointers to current position in screen pixel space | ||
656 | stbtt_aligned_quad *q, // output: quad to draw | ||
657 | int align_to_integer); | ||
658 | |||
659 | STBTT_DEF int stbtt_PackFontRangesGatherRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects); | ||
660 | STBTT_DEF void stbtt_PackFontRangesPackRects(stbtt_pack_context *spc, stbrp_rect *rects, int num_rects); | ||
661 | STBTT_DEF int stbtt_PackFontRangesRenderIntoRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects); | ||
662 | // Calling these functions in sequence is roughly equivalent to calling | ||
663 | // stbtt_PackFontRanges(). If you more control over the packing of multiple | ||
664 | // fonts, or if you want to pack custom data into a font texture, take a look | ||
665 | // at the source to of stbtt_PackFontRanges() and create a custom version | ||
666 | // using these functions, e.g. call GatherRects multiple times, | ||
667 | // building up a single array of rects, then call PackRects once, | ||
668 | // then call RenderIntoRects repeatedly. This may result in a | ||
669 | // better packing than calling PackFontRanges multiple times | ||
670 | // (or it may not). | ||
671 | |||
672 | // this is an opaque structure that you shouldn't mess with which holds | ||
673 | // all the context needed from PackBegin to PackEnd. | ||
674 | struct stbtt_pack_context { | ||
675 | void *user_allocator_context; | ||
676 | void *pack_info; | ||
677 | int width; | ||
678 | int height; | ||
679 | int stride_in_bytes; | ||
680 | int padding; | ||
681 | int skip_missing; | ||
682 | unsigned int h_oversample, v_oversample; | ||
683 | unsigned char *pixels; | ||
684 | void *nodes; | ||
685 | }; | ||
686 | |||
687 | ////////////////////////////////////////////////////////////////////////////// | ||
688 | // | ||
689 | // FONT LOADING | ||
690 | // | ||
691 | // | ||
692 | |||
693 | STBTT_DEF int stbtt_GetNumberOfFonts(const unsigned char *data); | ||
694 | // This function will determine the number of fonts in a font file. TrueType | ||
695 | // collection (.ttc) files may contain multiple fonts, while TrueType font | ||
696 | // (.ttf) files only contain one font. The number of fonts can be used for | ||
697 | // indexing with the previous function where the index is between zero and one | ||
698 | // less than the total fonts. If an error occurs, -1 is returned. | ||
699 | |||
700 | STBTT_DEF int stbtt_GetFontOffsetForIndex(const unsigned char *data, int index); | ||
701 | // Each .ttf/.ttc file may have more than one font. Each font has a sequential | ||
702 | // index number starting from 0. Call this function to get the font offset for | ||
703 | // a given index; it returns -1 if the index is out of range. A regular .ttf | ||
704 | // file will only define one font and it always be at offset 0, so it will | ||
705 | // return '0' for index 0, and -1 for all other indices. | ||
706 | |||
707 | // The following structure is defined publicly so you can declare one on | ||
708 | // the stack or as a global or etc, but you should treat it as opaque. | ||
709 | struct stbtt_fontinfo | ||
710 | { | ||
711 | void * userdata; | ||
712 | unsigned char * data; // pointer to .ttf file | ||
713 | int fontstart; // offset of start of font | ||
714 | |||
715 | int numGlyphs; // number of glyphs, needed for range checking | ||
716 | |||
717 | int loca,head,glyf,hhea,hmtx,kern,gpos,svg; // table locations as offset from start of .ttf | ||
718 | int index_map; // a cmap mapping for our chosen character encoding | ||
719 | int indexToLocFormat; // format needed to map from glyph index to glyph | ||
720 | |||
721 | stbtt__buf cff; // cff font data | ||
722 | stbtt__buf charstrings; // the charstring index | ||
723 | stbtt__buf gsubrs; // global charstring subroutines index | ||
724 | stbtt__buf subrs; // private charstring subroutines index | ||
725 | stbtt__buf fontdicts; // array of font dicts | ||
726 | stbtt__buf fdselect; // map from glyph to fontdict | ||
727 | }; | ||
728 | |||
729 | STBTT_DEF int stbtt_InitFont(stbtt_fontinfo *info, const unsigned char *data, int offset); | ||
730 | // Given an offset into the file that defines a font, this function builds | ||
731 | // the necessary cached info for the rest of the system. You must allocate | ||
732 | // the stbtt_fontinfo yourself, and stbtt_InitFont will fill it out. You don't | ||
733 | // need to do anything special to free it, because the contents are pure | ||
734 | // value data with no additional data structures. Returns 0 on failure. | ||
735 | |||
736 | |||
737 | ////////////////////////////////////////////////////////////////////////////// | ||
738 | // | ||
739 | // CHARACTER TO GLYPH-INDEX CONVERSIOn | ||
740 | |||
741 | STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codepoint); | ||
742 | // If you're going to perform multiple operations on the same character | ||
743 | // and you want a speed-up, call this function with the character you're | ||
744 | // going to process, then use glyph-based functions instead of the | ||
745 | // codepoint-based functions. | ||
746 | // Returns 0 if the character codepoint is not defined in the font. | ||
747 | |||
748 | |||
749 | ////////////////////////////////////////////////////////////////////////////// | ||
750 | // | ||
751 | // CHARACTER PROPERTIES | ||
752 | // | ||
753 | |||
754 | STBTT_DEF float stbtt_ScaleForPixelHeight(const stbtt_fontinfo *info, float pixels); | ||
755 | // computes a scale factor to produce a font whose "height" is 'pixels' tall. | ||
756 | // Height is measured as the distance from the highest ascender to the lowest | ||
757 | // descender; in other words, it's equivalent to calling stbtt_GetFontVMetrics | ||
758 | // and computing: | ||
759 | // scale = pixels / (ascent - descent) | ||
760 | // so if you prefer to measure height by the ascent only, use a similar calculation. | ||
761 | |||
762 | STBTT_DEF float stbtt_ScaleForMappingEmToPixels(const stbtt_fontinfo *info, float pixels); | ||
763 | // computes a scale factor to produce a font whose EM size is mapped to | ||
764 | // 'pixels' tall. This is probably what traditional APIs compute, but | ||
765 | // I'm not positive. | ||
766 | |||
767 | STBTT_DEF void stbtt_GetFontVMetrics(const stbtt_fontinfo *info, int *ascent, int *descent, int *lineGap); | ||
768 | // ascent is the coordinate above the baseline the font extends; descent | ||
769 | // is the coordinate below the baseline the font extends (i.e. it is typically negative) | ||
770 | // lineGap is the spacing between one row's descent and the next row's ascent... | ||
771 | // so you should advance the vertical position by "*ascent - *descent + *lineGap" | ||
772 | // these are expressed in unscaled coordinates, so you must multiply by | ||
773 | // the scale factor for a given size | ||
774 | |||
775 | STBTT_DEF int stbtt_GetFontVMetricsOS2(const stbtt_fontinfo *info, int *typoAscent, int *typoDescent, int *typoLineGap); | ||
776 | // analogous to GetFontVMetrics, but returns the "typographic" values from the OS/2 | ||
777 | // table (specific to MS/Windows TTF files). | ||
778 | // | ||
779 | // Returns 1 on success (table present), 0 on failure. | ||
780 | |||
781 | STBTT_DEF void stbtt_GetFontBoundingBox(const stbtt_fontinfo *info, int *x0, int *y0, int *x1, int *y1); | ||
782 | // the bounding box around all possible characters | ||
783 | |||
784 | STBTT_DEF void stbtt_GetCodepointHMetrics(const stbtt_fontinfo *info, int codepoint, int *advanceWidth, int *leftSideBearing); | ||
785 | // leftSideBearing is the offset from the current horizontal position to the left edge of the character | ||
786 | // advanceWidth is the offset from the current horizontal position to the next horizontal position | ||
787 | // these are expressed in unscaled coordinates | ||
788 | |||
789 | STBTT_DEF int stbtt_GetCodepointKernAdvance(const stbtt_fontinfo *info, int ch1, int ch2); | ||
790 | // an additional amount to add to the 'advance' value between ch1 and ch2 | ||
791 | |||
792 | STBTT_DEF int stbtt_GetCodepointBox(const stbtt_fontinfo *info, int codepoint, int *x0, int *y0, int *x1, int *y1); | ||
793 | // Gets the bounding box of the visible part of the glyph, in unscaled coordinates | ||
794 | |||
795 | STBTT_DEF void stbtt_GetGlyphHMetrics(const stbtt_fontinfo *info, int glyph_index, int *advanceWidth, int *leftSideBearing); | ||
796 | STBTT_DEF int stbtt_GetGlyphKernAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2); | ||
797 | STBTT_DEF int stbtt_GetGlyphBox(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1); | ||
798 | // as above, but takes one or more glyph indices for greater efficiency | ||
799 | |||
800 | typedef struct stbtt_kerningentry | ||
801 | { | ||
802 | int glyph1; // use stbtt_FindGlyphIndex | ||
803 | int glyph2; | ||
804 | int advance; | ||
805 | } stbtt_kerningentry; | ||
806 | |||
807 | STBTT_DEF int stbtt_GetKerningTableLength(const stbtt_fontinfo *info); | ||
808 | STBTT_DEF int stbtt_GetKerningTable(const stbtt_fontinfo *info, stbtt_kerningentry* table, int table_length); | ||
809 | // Retrieves a complete list of all of the kerning pairs provided by the font | ||
810 | // stbtt_GetKerningTable never writes more than table_length entries and returns how many entries it did write. | ||
811 | // The table will be sorted by (a.glyph1 == b.glyph1)?(a.glyph2 < b.glyph2):(a.glyph1 < b.glyph1) | ||
812 | |||
813 | ////////////////////////////////////////////////////////////////////////////// | ||
814 | // | ||
815 | // GLYPH SHAPES (you probably don't need these, but they have to go before | ||
816 | // the bitmaps for C declaration-order reasons) | ||
817 | // | ||
818 | |||
819 | #ifndef STBTT_vmove // you can predefine these to use different values (but why?) | ||
820 | enum { | ||
821 | STBTT_vmove=1, | ||
822 | STBTT_vline, | ||
823 | STBTT_vcurve, | ||
824 | STBTT_vcubic | ||
825 | }; | ||
826 | #endif | ||
827 | |||
828 | #ifndef stbtt_vertex // you can predefine this to use different values | ||
829 | // (we share this with other code at RAD) | ||
830 | #define stbtt_vertex_type short // can't use stbtt_int16 because that's not visible in the header file | ||
831 | typedef struct | ||
832 | { | ||
833 | stbtt_vertex_type x,y,cx,cy,cx1,cy1; | ||
834 | unsigned char type,padding; | ||
835 | } stbtt_vertex; | ||
836 | #endif | ||
837 | |||
838 | STBTT_DEF int stbtt_IsGlyphEmpty(const stbtt_fontinfo *info, int glyph_index); | ||
839 | // returns non-zero if nothing is drawn for this glyph | ||
840 | |||
841 | STBTT_DEF int stbtt_GetCodepointShape(const stbtt_fontinfo *info, int unicode_codepoint, stbtt_vertex **vertices); | ||
842 | STBTT_DEF int stbtt_GetGlyphShape(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **vertices); | ||
843 | // returns # of vertices and fills *vertices with the pointer to them | ||
844 | // these are expressed in "unscaled" coordinates | ||
845 | // | ||
846 | // The shape is a series of contours. Each one starts with | ||
847 | // a STBTT_moveto, then consists of a series of mixed | ||
848 | // STBTT_lineto and STBTT_curveto segments. A lineto | ||
849 | // draws a line from previous endpoint to its x,y; a curveto | ||
850 | // draws a quadratic bezier from previous endpoint to | ||
851 | // its x,y, using cx,cy as the bezier control point. | ||
852 | |||
853 | STBTT_DEF void stbtt_FreeShape(const stbtt_fontinfo *info, stbtt_vertex *vertices); | ||
854 | // frees the data allocated above | ||
855 | |||
856 | STBTT_DEF int stbtt_GetCodepointSVG(const stbtt_fontinfo *info, int unicode_codepoint, const char **svg); | ||
857 | STBTT_DEF int stbtt_GetGlyphSVG(const stbtt_fontinfo *info, int gl, const char **svg); | ||
858 | // fills svg with the character's SVG data. | ||
859 | // returns data size or 0 if SVG not found. | ||
860 | |||
861 | ////////////////////////////////////////////////////////////////////////////// | ||
862 | // | ||
863 | // BITMAP RENDERING | ||
864 | // | ||
865 | |||
866 | STBTT_DEF void stbtt_FreeBitmap(unsigned char *bitmap, void *userdata); | ||
867 | // frees the bitmap allocated below | ||
868 | |||
869 | STBTT_DEF unsigned char *stbtt_GetCodepointBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int codepoint, int *width, int *height, int *xoff, int *yoff); | ||
870 | // allocates a large-enough single-channel 8bpp bitmap and renders the | ||
871 | // specified character/glyph at the specified scale into it, with | ||
872 | // antialiasing. 0 is no coverage (transparent), 255 is fully covered (opaque). | ||
873 | // *width & *height are filled out with the width & height of the bitmap, | ||
874 | // which is stored left-to-right, top-to-bottom. | ||
875 | // | ||
876 | // xoff/yoff are the offset it pixel space from the glyph origin to the top-left of the bitmap | ||
877 | |||
878 | STBTT_DEF unsigned char *stbtt_GetCodepointBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint, int *width, int *height, int *xoff, int *yoff); | ||
879 | // the same as stbtt_GetCodepoitnBitmap, but you can specify a subpixel | ||
880 | // shift for the character | ||
881 | |||
882 | STBTT_DEF void stbtt_MakeCodepointBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int codepoint); | ||
883 | // the same as stbtt_GetCodepointBitmap, but you pass in storage for the bitmap | ||
884 | // in the form of 'output', with row spacing of 'out_stride' bytes. the bitmap | ||
885 | // is clipped to out_w/out_h bytes. Call stbtt_GetCodepointBitmapBox to get the | ||
886 | // width and height and positioning info for it first. | ||
887 | |||
888 | STBTT_DEF void stbtt_MakeCodepointBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint); | ||
889 | // same as stbtt_MakeCodepointBitmap, but you can specify a subpixel | ||
890 | // shift for the character | ||
891 | |||
892 | STBTT_DEF void stbtt_MakeCodepointBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int oversample_x, int oversample_y, float *sub_x, float *sub_y, int codepoint); | ||
893 | // same as stbtt_MakeCodepointBitmapSubpixel, but prefiltering | ||
894 | // is performed (see stbtt_PackSetOversampling) | ||
895 | |||
896 | STBTT_DEF void stbtt_GetCodepointBitmapBox(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1); | ||
897 | // get the bbox of the bitmap centered around the glyph origin; so the | ||
898 | // bitmap width is ix1-ix0, height is iy1-iy0, and location to place | ||
899 | // the bitmap top left is (leftSideBearing*scale,iy0). | ||
900 | // (Note that the bitmap uses y-increases-down, but the shape uses | ||
901 | // y-increases-up, so CodepointBitmapBox and CodepointBox are inverted.) | ||
902 | |||
903 | STBTT_DEF void stbtt_GetCodepointBitmapBoxSubpixel(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1); | ||
904 | // same as stbtt_GetCodepointBitmapBox, but you can specify a subpixel | ||
905 | // shift for the character | ||
906 | |||
907 | // the following functions are equivalent to the above functions, but operate | ||
908 | // on glyph indices instead of Unicode codepoints (for efficiency) | ||
909 | STBTT_DEF unsigned char *stbtt_GetGlyphBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int glyph, int *width, int *height, int *xoff, int *yoff); | ||
910 | STBTT_DEF unsigned char *stbtt_GetGlyphBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int glyph, int *width, int *height, int *xoff, int *yoff); | ||
911 | STBTT_DEF void stbtt_MakeGlyphBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int glyph); | ||
912 | STBTT_DEF void stbtt_MakeGlyphBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int glyph); | ||
913 | STBTT_DEF void stbtt_MakeGlyphBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int oversample_x, int oversample_y, float *sub_x, float *sub_y, int glyph); | ||
914 | STBTT_DEF void stbtt_GetGlyphBitmapBox(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1); | ||
915 | STBTT_DEF void stbtt_GetGlyphBitmapBoxSubpixel(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y,float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1); | ||
916 | |||
917 | |||
918 | // @TODO: don't expose this structure | ||
919 | typedef struct | ||
920 | { | ||
921 | int w,h,stride; | ||
922 | unsigned char *pixels; | ||
923 | } stbtt__bitmap; | ||
924 | |||
925 | // rasterize a shape with quadratic beziers into a bitmap | ||
926 | STBTT_DEF void stbtt_Rasterize(stbtt__bitmap *result, // 1-channel bitmap to draw into | ||
927 | float flatness_in_pixels, // allowable error of curve in pixels | ||
928 | stbtt_vertex *vertices, // array of vertices defining shape | ||
929 | int num_verts, // number of vertices in above array | ||
930 | float scale_x, float scale_y, // scale applied to input vertices | ||
931 | float shift_x, float shift_y, // translation applied to input vertices | ||
932 | int x_off, int y_off, // another translation applied to input | ||
933 | int invert, // if non-zero, vertically flip shape | ||
934 | void *userdata); // context for to STBTT_MALLOC | ||
935 | |||
936 | ////////////////////////////////////////////////////////////////////////////// | ||
937 | // | ||
938 | // Signed Distance Function (or Field) rendering | ||
939 | |||
940 | STBTT_DEF void stbtt_FreeSDF(unsigned char *bitmap, void *userdata); | ||
941 | // frees the SDF bitmap allocated below | ||
942 | |||
943 | STBTT_DEF unsigned char * stbtt_GetGlyphSDF(const stbtt_fontinfo *info, float scale, int glyph, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff); | ||
944 | STBTT_DEF unsigned char * stbtt_GetCodepointSDF(const stbtt_fontinfo *info, float scale, int codepoint, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff); | ||
945 | // These functions compute a discretized SDF field for a single character, suitable for storing | ||
946 | // in a single-channel texture, sampling with bilinear filtering, and testing against | ||
947 | // larger than some threshold to produce scalable fonts. | ||
948 | // info -- the font | ||
949 | // scale -- controls the size of the resulting SDF bitmap, same as it would be creating a regular bitmap | ||
950 | // glyph/codepoint -- the character to generate the SDF for | ||
951 | // padding -- extra "pixels" around the character which are filled with the distance to the character (not 0), | ||
952 | // which allows effects like bit outlines | ||
953 | // onedge_value -- value 0-255 to test the SDF against to reconstruct the character (i.e. the isocontour of the character) | ||
954 | // pixel_dist_scale -- what value the SDF should increase by when moving one SDF "pixel" away from the edge (on the 0..255 scale) | ||
955 | // if positive, > onedge_value is inside; if negative, < onedge_value is inside | ||
956 | // width,height -- output height & width of the SDF bitmap (including padding) | ||
957 | // xoff,yoff -- output origin of the character | ||
958 | // return value -- a 2D array of bytes 0..255, width*height in size | ||
959 | // | ||
960 | // pixel_dist_scale & onedge_value are a scale & bias that allows you to make | ||
961 | // optimal use of the limited 0..255 for your application, trading off precision | ||
962 | // and special effects. SDF values outside the range 0..255 are clamped to 0..255. | ||
963 | // | ||
964 | // Example: | ||
965 | // scale = stbtt_ScaleForPixelHeight(22) | ||
966 | // padding = 5 | ||
967 | // onedge_value = 180 | ||
968 | // pixel_dist_scale = 180/5.0 = 36.0 | ||
969 | // | ||
970 | // This will create an SDF bitmap in which the character is about 22 pixels | ||
971 | // high but the whole bitmap is about 22+5+5=32 pixels high. To produce a filled | ||
972 | // shape, sample the SDF at each pixel and fill the pixel if the SDF value | ||
973 | // is greater than or equal to 180/255. (You'll actually want to antialias, | ||
974 | // which is beyond the scope of this example.) Additionally, you can compute | ||
975 | // offset outlines (e.g. to stroke the character border inside & outside, | ||
976 | // or only outside). For example, to fill outside the character up to 3 SDF | ||
977 | // pixels, you would compare against (180-36.0*3)/255 = 72/255. The above | ||
978 | // choice of variables maps a range from 5 pixels outside the shape to | ||
979 | // 2 pixels inside the shape to 0..255; this is intended primarily for apply | ||
980 | // outside effects only (the interior range is needed to allow proper | ||
981 | // antialiasing of the font at *smaller* sizes) | ||
982 | // | ||
983 | // The function computes the SDF analytically at each SDF pixel, not by e.g. | ||
984 | // building a higher-res bitmap and approximating it. In theory the quality | ||
985 | // should be as high as possible for an SDF of this size & representation, but | ||
986 | // unclear if this is true in practice (perhaps building a higher-res bitmap | ||
987 | // and computing from that can allow drop-out prevention). | ||
988 | // | ||
989 | // The algorithm has not been optimized at all, so expect it to be slow | ||
990 | // if computing lots of characters or very large sizes. | ||
991 | |||
992 | |||
993 | |||
994 | ////////////////////////////////////////////////////////////////////////////// | ||
995 | // | ||
996 | // Finding the right font... | ||
997 | // | ||
998 | // You should really just solve this offline, keep your own tables | ||
999 | // of what font is what, and don't try to get it out of the .ttf file. | ||
1000 | // That's because getting it out of the .ttf file is really hard, because | ||
1001 | // the names in the file can appear in many possible encodings, in many | ||
1002 | // possible languages, and e.g. if you need a case-insensitive comparison, | ||
1003 | // the details of that depend on the encoding & language in a complex way | ||
1004 | // (actually underspecified in truetype, but also gigantic). | ||
1005 | // | ||
1006 | // But you can use the provided functions in two possible ways: | ||
1007 | // stbtt_FindMatchingFont() will use *case-sensitive* comparisons on | ||
1008 | // unicode-encoded names to try to find the font you want; | ||
1009 | // you can run this before calling stbtt_InitFont() | ||
1010 | // | ||
1011 | // stbtt_GetFontNameString() lets you get any of the various strings | ||
1012 | // from the file yourself and do your own comparisons on them. | ||
1013 | // You have to have called stbtt_InitFont() first. | ||
1014 | |||
1015 | |||
1016 | STBTT_DEF int stbtt_FindMatchingFont(const unsigned char *fontdata, const char *name, int flags); | ||
1017 | // returns the offset (not index) of the font that matches, or -1 if none | ||
1018 | // if you use STBTT_MACSTYLE_DONTCARE, use a font name like "Arial Bold". | ||
1019 | // if you use any other flag, use a font name like "Arial"; this checks | ||
1020 | // the 'macStyle' header field; i don't know if fonts set this consistently | ||
1021 | #define STBTT_MACSTYLE_DONTCARE 0 | ||
1022 | #define STBTT_MACSTYLE_BOLD 1 | ||
1023 | #define STBTT_MACSTYLE_ITALIC 2 | ||
1024 | #define STBTT_MACSTYLE_UNDERSCORE 4 | ||
1025 | #define STBTT_MACSTYLE_NONE 8 // <= not same as 0, this makes us check the bitfield is 0 | ||
1026 | |||
1027 | STBTT_DEF int stbtt_CompareUTF8toUTF16_bigendian(const char *s1, int len1, const char *s2, int len2); | ||
1028 | // returns 1/0 whether the first string interpreted as utf8 is identical to | ||
1029 | // the second string interpreted as big-endian utf16... useful for strings from next func | ||
1030 | |||
1031 | STBTT_DEF const char *stbtt_GetFontNameString(const stbtt_fontinfo *font, int *length, int platformID, int encodingID, int languageID, int nameID); | ||
1032 | // returns the string (which may be big-endian double byte, e.g. for unicode) | ||
1033 | // and puts the length in bytes in *length. | ||
1034 | // | ||
1035 | // some of the values for the IDs are below; for more see the truetype spec: | ||
1036 | // http://developer.apple.com/textfonts/TTRefMan/RM06/Chap6name.html | ||
1037 | // http://www.microsoft.com/typography/otspec/name.htm | ||
1038 | |||
1039 | enum { // platformID | ||
1040 | STBTT_PLATFORM_ID_UNICODE =0, | ||
1041 | STBTT_PLATFORM_ID_MAC =1, | ||
1042 | STBTT_PLATFORM_ID_ISO =2, | ||
1043 | STBTT_PLATFORM_ID_MICROSOFT =3 | ||
1044 | }; | ||
1045 | |||
1046 | enum { // encodingID for STBTT_PLATFORM_ID_UNICODE | ||
1047 | STBTT_UNICODE_EID_UNICODE_1_0 =0, | ||
1048 | STBTT_UNICODE_EID_UNICODE_1_1 =1, | ||
1049 | STBTT_UNICODE_EID_ISO_10646 =2, | ||
1050 | STBTT_UNICODE_EID_UNICODE_2_0_BMP=3, | ||
1051 | STBTT_UNICODE_EID_UNICODE_2_0_FULL=4 | ||
1052 | }; | ||
1053 | |||
1054 | enum { // encodingID for STBTT_PLATFORM_ID_MICROSOFT | ||
1055 | STBTT_MS_EID_SYMBOL =0, | ||
1056 | STBTT_MS_EID_UNICODE_BMP =1, | ||
1057 | STBTT_MS_EID_SHIFTJIS =2, | ||
1058 | STBTT_MS_EID_UNICODE_FULL =10 | ||
1059 | }; | ||
1060 | |||
1061 | enum { // encodingID for STBTT_PLATFORM_ID_MAC; same as Script Manager codes | ||
1062 | STBTT_MAC_EID_ROMAN =0, STBTT_MAC_EID_ARABIC =4, | ||
1063 | STBTT_MAC_EID_JAPANESE =1, STBTT_MAC_EID_HEBREW =5, | ||
1064 | STBTT_MAC_EID_CHINESE_TRAD =2, STBTT_MAC_EID_GREEK =6, | ||
1065 | STBTT_MAC_EID_KOREAN =3, STBTT_MAC_EID_RUSSIAN =7 | ||
1066 | }; | ||
1067 | |||
1068 | enum { // languageID for STBTT_PLATFORM_ID_MICROSOFT; same as LCID... | ||
1069 | // problematic because there are e.g. 16 english LCIDs and 16 arabic LCIDs | ||
1070 | STBTT_MS_LANG_ENGLISH =0x0409, STBTT_MS_LANG_ITALIAN =0x0410, | ||
1071 | STBTT_MS_LANG_CHINESE =0x0804, STBTT_MS_LANG_JAPANESE =0x0411, | ||
1072 | STBTT_MS_LANG_DUTCH =0x0413, STBTT_MS_LANG_KOREAN =0x0412, | ||
1073 | STBTT_MS_LANG_FRENCH =0x040c, STBTT_MS_LANG_RUSSIAN =0x0419, | ||
1074 | STBTT_MS_LANG_GERMAN =0x0407, STBTT_MS_LANG_SPANISH =0x0409, | ||
1075 | STBTT_MS_LANG_HEBREW =0x040d, STBTT_MS_LANG_SWEDISH =0x041D | ||
1076 | }; | ||
1077 | |||
1078 | enum { // languageID for STBTT_PLATFORM_ID_MAC | ||
1079 | STBTT_MAC_LANG_ENGLISH =0 , STBTT_MAC_LANG_JAPANESE =11, | ||
1080 | STBTT_MAC_LANG_ARABIC =12, STBTT_MAC_LANG_KOREAN =23, | ||
1081 | STBTT_MAC_LANG_DUTCH =4 , STBTT_MAC_LANG_RUSSIAN =32, | ||
1082 | STBTT_MAC_LANG_FRENCH =1 , STBTT_MAC_LANG_SPANISH =6 , | ||
1083 | STBTT_MAC_LANG_GERMAN =2 , STBTT_MAC_LANG_SWEDISH =5 , | ||
1084 | STBTT_MAC_LANG_HEBREW =10, STBTT_MAC_LANG_CHINESE_SIMPLIFIED =33, | ||
1085 | STBTT_MAC_LANG_ITALIAN =3 , STBTT_MAC_LANG_CHINESE_TRAD =19 | ||
1086 | }; | ||
1087 | |||
1088 | #ifdef __cplusplus | ||
1089 | } | ||
1090 | #endif | ||
1091 | |||
1092 | #endif // __STB_INCLUDE_STB_TRUETYPE_H__ | ||
1093 | |||
1094 | /////////////////////////////////////////////////////////////////////////////// | ||
1095 | /////////////////////////////////////////////////////////////////////////////// | ||
1096 | //// | ||
1097 | //// IMPLEMENTATION | ||
1098 | //// | ||
1099 | //// | ||
1100 | |||
1101 | #ifdef STB_TRUETYPE_IMPLEMENTATION | ||
1102 | |||
1103 | #ifndef STBTT_MAX_OVERSAMPLE | ||
1104 | #define STBTT_MAX_OVERSAMPLE 8 | ||
1105 | #endif | ||
1106 | |||
1107 | #if STBTT_MAX_OVERSAMPLE > 255 | ||
1108 | #error "STBTT_MAX_OVERSAMPLE cannot be > 255" | ||
1109 | #endif | ||
1110 | |||
1111 | typedef int stbtt__test_oversample_pow2[(STBTT_MAX_OVERSAMPLE & (STBTT_MAX_OVERSAMPLE-1)) == 0 ? 1 : -1]; | ||
1112 | |||
1113 | #ifndef STBTT_RASTERIZER_VERSION | ||
1114 | #define STBTT_RASTERIZER_VERSION 2 | ||
1115 | #endif | ||
1116 | |||
1117 | #ifdef _MSC_VER | ||
1118 | #define STBTT__NOTUSED(v) (void)(v) | ||
1119 | #else | ||
1120 | #define STBTT__NOTUSED(v) (void)sizeof(v) | ||
1121 | #endif | ||
1122 | |||
1123 | ////////////////////////////////////////////////////////////////////////// | ||
1124 | // | ||
1125 | // stbtt__buf helpers to parse data from file | ||
1126 | // | ||
1127 | |||
1128 | static stbtt_uint8 stbtt__buf_get8(stbtt__buf *b) | ||
1129 | { | ||
1130 | if (b->cursor >= b->size) | ||
1131 | return 0; | ||
1132 | return b->data[b->cursor++]; | ||
1133 | } | ||
1134 | |||
1135 | static stbtt_uint8 stbtt__buf_peek8(stbtt__buf *b) | ||
1136 | { | ||
1137 | if (b->cursor >= b->size) | ||
1138 | return 0; | ||
1139 | return b->data[b->cursor]; | ||
1140 | } | ||
1141 | |||
1142 | static void stbtt__buf_seek(stbtt__buf *b, int o) | ||
1143 | { | ||
1144 | STBTT_assert(!(o > b->size || o < 0)); | ||
1145 | b->cursor = (o > b->size || o < 0) ? b->size : o; | ||
1146 | } | ||
1147 | |||
1148 | static void stbtt__buf_skip(stbtt__buf *b, int o) | ||
1149 | { | ||
1150 | stbtt__buf_seek(b, b->cursor + o); | ||
1151 | } | ||
1152 | |||
1153 | static stbtt_uint32 stbtt__buf_get(stbtt__buf *b, int n) | ||
1154 | { | ||
1155 | stbtt_uint32 v = 0; | ||
1156 | int i; | ||
1157 | STBTT_assert(n >= 1 && n <= 4); | ||
1158 | for (i = 0; i < n; i++) | ||
1159 | v = (v << 8) | stbtt__buf_get8(b); | ||
1160 | return v; | ||
1161 | } | ||
1162 | |||
1163 | static stbtt__buf stbtt__new_buf(const void *p, size_t size) | ||
1164 | { | ||
1165 | stbtt__buf r; | ||
1166 | STBTT_assert(size < 0x40000000); | ||
1167 | r.data = (stbtt_uint8*) p; | ||
1168 | r.size = (int) size; | ||
1169 | r.cursor = 0; | ||
1170 | return r; | ||
1171 | } | ||
1172 | |||
1173 | #define stbtt__buf_get16(b) stbtt__buf_get((b), 2) | ||
1174 | #define stbtt__buf_get32(b) stbtt__buf_get((b), 4) | ||
1175 | |||
1176 | static stbtt__buf stbtt__buf_range(const stbtt__buf *b, int o, int s) | ||
1177 | { | ||
1178 | stbtt__buf r = stbtt__new_buf(NULL, 0); | ||
1179 | if (o < 0 || s < 0 || o > b->size || s > b->size - o) return r; | ||
1180 | r.data = b->data + o; | ||
1181 | r.size = s; | ||
1182 | return r; | ||
1183 | } | ||
1184 | |||
1185 | static stbtt__buf stbtt__cff_get_index(stbtt__buf *b) | ||
1186 | { | ||
1187 | int count, start, offsize; | ||
1188 | start = b->cursor; | ||
1189 | count = stbtt__buf_get16(b); | ||
1190 | if (count) { | ||
1191 | offsize = stbtt__buf_get8(b); | ||
1192 | STBTT_assert(offsize >= 1 && offsize <= 4); | ||
1193 | stbtt__buf_skip(b, offsize * count); | ||
1194 | stbtt__buf_skip(b, stbtt__buf_get(b, offsize) - 1); | ||
1195 | } | ||
1196 | return stbtt__buf_range(b, start, b->cursor - start); | ||
1197 | } | ||
1198 | |||
1199 | static stbtt_uint32 stbtt__cff_int(stbtt__buf *b) | ||
1200 | { | ||
1201 | int b0 = stbtt__buf_get8(b); | ||
1202 | if (b0 >= 32 && b0 <= 246) return b0 - 139; | ||
1203 | else if (b0 >= 247 && b0 <= 250) return (b0 - 247)*256 + stbtt__buf_get8(b) + 108; | ||
1204 | else if (b0 >= 251 && b0 <= 254) return -(b0 - 251)*256 - stbtt__buf_get8(b) - 108; | ||
1205 | else if (b0 == 28) return stbtt__buf_get16(b); | ||
1206 | else if (b0 == 29) return stbtt__buf_get32(b); | ||
1207 | STBTT_assert(0); | ||
1208 | return 0; | ||
1209 | } | ||
1210 | |||
1211 | static void stbtt__cff_skip_operand(stbtt__buf *b) { | ||
1212 | int v, b0 = stbtt__buf_peek8(b); | ||
1213 | STBTT_assert(b0 >= 28); | ||
1214 | if (b0 == 30) { | ||
1215 | stbtt__buf_skip(b, 1); | ||
1216 | while (b->cursor < b->size) { | ||
1217 | v = stbtt__buf_get8(b); | ||
1218 | if ((v & 0xF) == 0xF || (v >> 4) == 0xF) | ||
1219 | break; | ||
1220 | } | ||
1221 | } else { | ||
1222 | stbtt__cff_int(b); | ||
1223 | } | ||
1224 | } | ||
1225 | |||
1226 | static stbtt__buf stbtt__dict_get(stbtt__buf *b, int key) | ||
1227 | { | ||
1228 | stbtt__buf_seek(b, 0); | ||
1229 | while (b->cursor < b->size) { | ||
1230 | int start = b->cursor, end, op; | ||
1231 | while (stbtt__buf_peek8(b) >= 28) | ||
1232 | stbtt__cff_skip_operand(b); | ||
1233 | end = b->cursor; | ||
1234 | op = stbtt__buf_get8(b); | ||
1235 | if (op == 12) op = stbtt__buf_get8(b) | 0x100; | ||
1236 | if (op == key) return stbtt__buf_range(b, start, end-start); | ||
1237 | } | ||
1238 | return stbtt__buf_range(b, 0, 0); | ||
1239 | } | ||
1240 | |||
1241 | static void stbtt__dict_get_ints(stbtt__buf *b, int key, int outcount, stbtt_uint32 *out) | ||
1242 | { | ||
1243 | int i; | ||
1244 | stbtt__buf operands = stbtt__dict_get(b, key); | ||
1245 | for (i = 0; i < outcount && operands.cursor < operands.size; i++) | ||
1246 | out[i] = stbtt__cff_int(&operands); | ||
1247 | } | ||
1248 | |||
1249 | static int stbtt__cff_index_count(stbtt__buf *b) | ||
1250 | { | ||
1251 | stbtt__buf_seek(b, 0); | ||
1252 | return stbtt__buf_get16(b); | ||
1253 | } | ||
1254 | |||
1255 | static stbtt__buf stbtt__cff_index_get(stbtt__buf b, int i) | ||
1256 | { | ||
1257 | int count, offsize, start, end; | ||
1258 | stbtt__buf_seek(&b, 0); | ||
1259 | count = stbtt__buf_get16(&b); | ||
1260 | offsize = stbtt__buf_get8(&b); | ||
1261 | STBTT_assert(i >= 0 && i < count); | ||
1262 | STBTT_assert(offsize >= 1 && offsize <= 4); | ||
1263 | stbtt__buf_skip(&b, i*offsize); | ||
1264 | start = stbtt__buf_get(&b, offsize); | ||
1265 | end = stbtt__buf_get(&b, offsize); | ||
1266 | return stbtt__buf_range(&b, 2+(count+1)*offsize+start, end - start); | ||
1267 | } | ||
1268 | |||
1269 | ////////////////////////////////////////////////////////////////////////// | ||
1270 | // | ||
1271 | // accessors to parse data from file | ||
1272 | // | ||
1273 | |||
1274 | // on platforms that don't allow misaligned reads, if we want to allow | ||
1275 | // truetype fonts that aren't padded to alignment, define ALLOW_UNALIGNED_TRUETYPE | ||
1276 | |||
1277 | #define ttBYTE(p) (* (stbtt_uint8 *) (p)) | ||
1278 | #define ttCHAR(p) (* (stbtt_int8 *) (p)) | ||
1279 | #define ttFixed(p) ttLONG(p) | ||
1280 | |||
1281 | static stbtt_uint16 ttUSHORT(stbtt_uint8 *p) { return p[0]*256 + p[1]; } | ||
1282 | static stbtt_int16 ttSHORT(stbtt_uint8 *p) { return p[0]*256 + p[1]; } | ||
1283 | static stbtt_uint32 ttULONG(stbtt_uint8 *p) { return (p[0]<<24) + (p[1]<<16) + (p[2]<<8) + p[3]; } | ||
1284 | static stbtt_int32 ttLONG(stbtt_uint8 *p) { return (p[0]<<24) + (p[1]<<16) + (p[2]<<8) + p[3]; } | ||
1285 | |||
1286 | #define stbtt_tag4(p,c0,c1,c2,c3) ((p)[0] == (c0) && (p)[1] == (c1) && (p)[2] == (c2) && (p)[3] == (c3)) | ||
1287 | #define stbtt_tag(p,str) stbtt_tag4(p,str[0],str[1],str[2],str[3]) | ||
1288 | |||
1289 | static int stbtt__isfont(stbtt_uint8 *font) | ||
1290 | { | ||
1291 | // check the version number | ||
1292 | if (stbtt_tag4(font, '1',0,0,0)) return 1; // TrueType 1 | ||
1293 | if (stbtt_tag(font, "typ1")) return 1; // TrueType with type 1 font -- we don't support this! | ||
1294 | if (stbtt_tag(font, "OTTO")) return 1; // OpenType with CFF | ||
1295 | if (stbtt_tag4(font, 0,1,0,0)) return 1; // OpenType 1.0 | ||
1296 | if (stbtt_tag(font, "true")) return 1; // Apple specification for TrueType fonts | ||
1297 | return 0; | ||
1298 | } | ||
1299 | |||
1300 | // @OPTIMIZE: binary search | ||
1301 | static stbtt_uint32 stbtt__find_table(stbtt_uint8 *data, stbtt_uint32 fontstart, const char *tag) | ||
1302 | { | ||
1303 | stbtt_int32 num_tables = ttUSHORT(data+fontstart+4); | ||
1304 | stbtt_uint32 tabledir = fontstart + 12; | ||
1305 | stbtt_int32 i; | ||
1306 | for (i=0; i < num_tables; ++i) { | ||
1307 | stbtt_uint32 loc = tabledir + 16*i; | ||
1308 | if (stbtt_tag(data+loc+0, tag)) | ||
1309 | return ttULONG(data+loc+8); | ||
1310 | } | ||
1311 | return 0; | ||
1312 | } | ||
1313 | |||
1314 | static int stbtt_GetFontOffsetForIndex_internal(unsigned char *font_collection, int index) | ||
1315 | { | ||
1316 | // if it's just a font, there's only one valid index | ||
1317 | if (stbtt__isfont(font_collection)) | ||
1318 | return index == 0 ? 0 : -1; | ||
1319 | |||
1320 | // check if it's a TTC | ||
1321 | if (stbtt_tag(font_collection, "ttcf")) { | ||
1322 | // version 1? | ||
1323 | if (ttULONG(font_collection+4) == 0x00010000 || ttULONG(font_collection+4) == 0x00020000) { | ||
1324 | stbtt_int32 n = ttLONG(font_collection+8); | ||
1325 | if (index >= n) | ||
1326 | return -1; | ||
1327 | return ttULONG(font_collection+12+index*4); | ||
1328 | } | ||
1329 | } | ||
1330 | return -1; | ||
1331 | } | ||
1332 | |||
1333 | static int stbtt_GetNumberOfFonts_internal(unsigned char *font_collection) | ||
1334 | { | ||
1335 | // if it's just a font, there's only one valid font | ||
1336 | if (stbtt__isfont(font_collection)) | ||
1337 | return 1; | ||
1338 | |||
1339 | // check if it's a TTC | ||
1340 | if (stbtt_tag(font_collection, "ttcf")) { | ||
1341 | // version 1? | ||
1342 | if (ttULONG(font_collection+4) == 0x00010000 || ttULONG(font_collection+4) == 0x00020000) { | ||
1343 | return ttLONG(font_collection+8); | ||
1344 | } | ||
1345 | } | ||
1346 | return 0; | ||
1347 | } | ||
1348 | |||
1349 | static stbtt__buf stbtt__get_subrs(stbtt__buf cff, stbtt__buf fontdict) | ||
1350 | { | ||
1351 | stbtt_uint32 subrsoff = 0, private_loc[2] = { 0, 0 }; | ||
1352 | stbtt__buf pdict; | ||
1353 | stbtt__dict_get_ints(&fontdict, 18, 2, private_loc); | ||
1354 | if (!private_loc[1] || !private_loc[0]) return stbtt__new_buf(NULL, 0); | ||
1355 | pdict = stbtt__buf_range(&cff, private_loc[1], private_loc[0]); | ||
1356 | stbtt__dict_get_ints(&pdict, 19, 1, &subrsoff); | ||
1357 | if (!subrsoff) return stbtt__new_buf(NULL, 0); | ||
1358 | stbtt__buf_seek(&cff, private_loc[1]+subrsoff); | ||
1359 | return stbtt__cff_get_index(&cff); | ||
1360 | } | ||
1361 | |||
1362 | // since most people won't use this, find this table the first time it's needed | ||
1363 | static int stbtt__get_svg(stbtt_fontinfo *info) | ||
1364 | { | ||
1365 | stbtt_uint32 t; | ||
1366 | if (info->svg < 0) { | ||
1367 | t = stbtt__find_table(info->data, info->fontstart, "SVG "); | ||
1368 | if (t) { | ||
1369 | stbtt_uint32 offset = ttULONG(info->data + t + 2); | ||
1370 | info->svg = t + offset; | ||
1371 | } else { | ||
1372 | info->svg = 0; | ||
1373 | } | ||
1374 | } | ||
1375 | return info->svg; | ||
1376 | } | ||
1377 | |||
1378 | static int stbtt_InitFont_internal(stbtt_fontinfo *info, unsigned char *data, int fontstart) | ||
1379 | { | ||
1380 | stbtt_uint32 cmap, t; | ||
1381 | stbtt_int32 i,numTables; | ||
1382 | |||
1383 | info->data = data; | ||
1384 | info->fontstart = fontstart; | ||
1385 | info->cff = stbtt__new_buf(NULL, 0); | ||
1386 | |||
1387 | cmap = stbtt__find_table(data, fontstart, "cmap"); // required | ||
1388 | info->loca = stbtt__find_table(data, fontstart, "loca"); // required | ||
1389 | info->head = stbtt__find_table(data, fontstart, "head"); // required | ||
1390 | info->glyf = stbtt__find_table(data, fontstart, "glyf"); // required | ||
1391 | info->hhea = stbtt__find_table(data, fontstart, "hhea"); // required | ||
1392 | info->hmtx = stbtt__find_table(data, fontstart, "hmtx"); // required | ||
1393 | info->kern = stbtt__find_table(data, fontstart, "kern"); // not required | ||
1394 | info->gpos = stbtt__find_table(data, fontstart, "GPOS"); // not required | ||
1395 | |||
1396 | if (!cmap || !info->head || !info->hhea || !info->hmtx) | ||
1397 | return 0; | ||
1398 | if (info->glyf) { | ||
1399 | // required for truetype | ||
1400 | if (!info->loca) return 0; | ||
1401 | } else { | ||
1402 | // initialization for CFF / Type2 fonts (OTF) | ||
1403 | stbtt__buf b, topdict, topdictidx; | ||
1404 | stbtt_uint32 cstype = 2, charstrings = 0, fdarrayoff = 0, fdselectoff = 0; | ||
1405 | stbtt_uint32 cff; | ||
1406 | |||
1407 | cff = stbtt__find_table(data, fontstart, "CFF "); | ||
1408 | if (!cff) return 0; | ||
1409 | |||
1410 | info->fontdicts = stbtt__new_buf(NULL, 0); | ||
1411 | info->fdselect = stbtt__new_buf(NULL, 0); | ||
1412 | |||
1413 | // @TODO this should use size from table (not 512MB) | ||
1414 | info->cff = stbtt__new_buf(data+cff, 512*1024*1024); | ||
1415 | b = info->cff; | ||
1416 | |||
1417 | // read the header | ||
1418 | stbtt__buf_skip(&b, 2); | ||
1419 | stbtt__buf_seek(&b, stbtt__buf_get8(&b)); // hdrsize | ||
1420 | |||
1421 | // @TODO the name INDEX could list multiple fonts, | ||
1422 | // but we just use the first one. | ||
1423 | stbtt__cff_get_index(&b); // name INDEX | ||
1424 | topdictidx = stbtt__cff_get_index(&b); | ||
1425 | topdict = stbtt__cff_index_get(topdictidx, 0); | ||
1426 | stbtt__cff_get_index(&b); // string INDEX | ||
1427 | info->gsubrs = stbtt__cff_get_index(&b); | ||
1428 | |||
1429 | stbtt__dict_get_ints(&topdict, 17, 1, &charstrings); | ||
1430 | stbtt__dict_get_ints(&topdict, 0x100 | 6, 1, &cstype); | ||
1431 | stbtt__dict_get_ints(&topdict, 0x100 | 36, 1, &fdarrayoff); | ||
1432 | stbtt__dict_get_ints(&topdict, 0x100 | 37, 1, &fdselectoff); | ||
1433 | info->subrs = stbtt__get_subrs(b, topdict); | ||
1434 | |||
1435 | // we only support Type 2 charstrings | ||
1436 | if (cstype != 2) return 0; | ||
1437 | if (charstrings == 0) return 0; | ||
1438 | |||
1439 | if (fdarrayoff) { | ||
1440 | // looks like a CID font | ||
1441 | if (!fdselectoff) return 0; | ||
1442 | stbtt__buf_seek(&b, fdarrayoff); | ||
1443 | info->fontdicts = stbtt__cff_get_index(&b); | ||
1444 | info->fdselect = stbtt__buf_range(&b, fdselectoff, b.size-fdselectoff); | ||
1445 | } | ||
1446 | |||
1447 | stbtt__buf_seek(&b, charstrings); | ||
1448 | info->charstrings = stbtt__cff_get_index(&b); | ||
1449 | } | ||
1450 | |||
1451 | t = stbtt__find_table(data, fontstart, "maxp"); | ||
1452 | if (t) | ||
1453 | info->numGlyphs = ttUSHORT(data+t+4); | ||
1454 | else | ||
1455 | info->numGlyphs = 0xffff; | ||
1456 | |||
1457 | info->svg = -1; | ||
1458 | |||
1459 | // find a cmap encoding table we understand *now* to avoid searching | ||
1460 | // later. (todo: could make this installable) | ||
1461 | // the same regardless of glyph. | ||
1462 | numTables = ttUSHORT(data + cmap + 2); | ||
1463 | info->index_map = 0; | ||
1464 | for (i=0; i < numTables; ++i) { | ||
1465 | stbtt_uint32 encoding_record = cmap + 4 + 8 * i; | ||
1466 | // find an encoding we understand: | ||
1467 | switch(ttUSHORT(data+encoding_record)) { | ||
1468 | case STBTT_PLATFORM_ID_MICROSOFT: | ||
1469 | switch (ttUSHORT(data+encoding_record+2)) { | ||
1470 | case STBTT_MS_EID_UNICODE_BMP: | ||
1471 | case STBTT_MS_EID_UNICODE_FULL: | ||
1472 | // MS/Unicode | ||
1473 | info->index_map = cmap + ttULONG(data+encoding_record+4); | ||
1474 | break; | ||
1475 | } | ||
1476 | break; | ||
1477 | case STBTT_PLATFORM_ID_UNICODE: | ||
1478 | // Mac/iOS has these | ||
1479 | // all the encodingIDs are unicode, so we don't bother to check it | ||
1480 | info->index_map = cmap + ttULONG(data+encoding_record+4); | ||
1481 | break; | ||
1482 | } | ||
1483 | } | ||
1484 | if (info->index_map == 0) | ||
1485 | return 0; | ||
1486 | |||
1487 | info->indexToLocFormat = ttUSHORT(data+info->head + 50); | ||
1488 | return 1; | ||
1489 | } | ||
1490 | |||
1491 | STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codepoint) | ||
1492 | { | ||
1493 | stbtt_uint8 *data = info->data; | ||
1494 | stbtt_uint32 index_map = info->index_map; | ||
1495 | |||
1496 | stbtt_uint16 format = ttUSHORT(data + index_map + 0); | ||
1497 | if (format == 0) { // apple byte encoding | ||
1498 | stbtt_int32 bytes = ttUSHORT(data + index_map + 2); | ||
1499 | if (unicode_codepoint < bytes-6) | ||
1500 | return ttBYTE(data + index_map + 6 + unicode_codepoint); | ||
1501 | return 0; | ||
1502 | } else if (format == 6) { | ||
1503 | stbtt_uint32 first = ttUSHORT(data + index_map + 6); | ||
1504 | stbtt_uint32 count = ttUSHORT(data + index_map + 8); | ||
1505 | if ((stbtt_uint32) unicode_codepoint >= first && (stbtt_uint32) unicode_codepoint < first+count) | ||
1506 | return ttUSHORT(data + index_map + 10 + (unicode_codepoint - first)*2); | ||
1507 | return 0; | ||
1508 | } else if (format == 2) { | ||
1509 | STBTT_assert(0); // @TODO: high-byte mapping for japanese/chinese/korean | ||
1510 | return 0; | ||
1511 | } else if (format == 4) { // standard mapping for windows fonts: binary search collection of ranges | ||
1512 | stbtt_uint16 segcount = ttUSHORT(data+index_map+6) >> 1; | ||
1513 | stbtt_uint16 searchRange = ttUSHORT(data+index_map+8) >> 1; | ||
1514 | stbtt_uint16 entrySelector = ttUSHORT(data+index_map+10); | ||
1515 | stbtt_uint16 rangeShift = ttUSHORT(data+index_map+12) >> 1; | ||
1516 | |||
1517 | // do a binary search of the segments | ||
1518 | stbtt_uint32 endCount = index_map + 14; | ||
1519 | stbtt_uint32 search = endCount; | ||
1520 | |||
1521 | if (unicode_codepoint > 0xffff) | ||
1522 | return 0; | ||
1523 | |||
1524 | // they lie from endCount .. endCount + segCount | ||
1525 | // but searchRange is the nearest power of two, so... | ||
1526 | if (unicode_codepoint >= ttUSHORT(data + search + rangeShift*2)) | ||
1527 | search += rangeShift*2; | ||
1528 | |||
1529 | // now decrement to bias correctly to find smallest | ||
1530 | search -= 2; | ||
1531 | while (entrySelector) { | ||
1532 | stbtt_uint16 end; | ||
1533 | searchRange >>= 1; | ||
1534 | end = ttUSHORT(data + search + searchRange*2); | ||
1535 | if (unicode_codepoint > end) | ||
1536 | search += searchRange*2; | ||
1537 | --entrySelector; | ||
1538 | } | ||
1539 | search += 2; | ||
1540 | |||
1541 | { | ||
1542 | stbtt_uint16 offset, start; | ||
1543 | stbtt_uint16 item = (stbtt_uint16) ((search - endCount) >> 1); | ||
1544 | |||
1545 | STBTT_assert(unicode_codepoint <= ttUSHORT(data + endCount + 2*item)); | ||
1546 | start = ttUSHORT(data + index_map + 14 + segcount*2 + 2 + 2*item); | ||
1547 | if (unicode_codepoint < start) | ||
1548 | return 0; | ||
1549 | |||
1550 | offset = ttUSHORT(data + index_map + 14 + segcount*6 + 2 + 2*item); | ||
1551 | if (offset == 0) | ||
1552 | return (stbtt_uint16) (unicode_codepoint + ttSHORT(data + index_map + 14 + segcount*4 + 2 + 2*item)); | ||
1553 | |||
1554 | return ttUSHORT(data + offset + (unicode_codepoint-start)*2 + index_map + 14 + segcount*6 + 2 + 2*item); | ||
1555 | } | ||
1556 | } else if (format == 12 || format == 13) { | ||
1557 | stbtt_uint32 ngroups = ttULONG(data+index_map+12); | ||
1558 | stbtt_int32 low,high; | ||
1559 | low = 0; high = (stbtt_int32)ngroups; | ||
1560 | // Binary search the right group. | ||
1561 | while (low < high) { | ||
1562 | stbtt_int32 mid = low + ((high-low) >> 1); // rounds down, so low <= mid < high | ||
1563 | stbtt_uint32 start_char = ttULONG(data+index_map+16+mid*12); | ||
1564 | stbtt_uint32 end_char = ttULONG(data+index_map+16+mid*12+4); | ||
1565 | if ((stbtt_uint32) unicode_codepoint < start_char) | ||
1566 | high = mid; | ||
1567 | else if ((stbtt_uint32) unicode_codepoint > end_char) | ||
1568 | low = mid+1; | ||
1569 | else { | ||
1570 | stbtt_uint32 start_glyph = ttULONG(data+index_map+16+mid*12+8); | ||
1571 | if (format == 12) | ||
1572 | return start_glyph + unicode_codepoint-start_char; | ||
1573 | else // format == 13 | ||
1574 | return start_glyph; | ||
1575 | } | ||
1576 | } | ||
1577 | return 0; // not found | ||
1578 | } | ||
1579 | // @TODO | ||
1580 | STBTT_assert(0); | ||
1581 | return 0; | ||
1582 | } | ||
1583 | |||
1584 | STBTT_DEF int stbtt_GetCodepointShape(const stbtt_fontinfo *info, int unicode_codepoint, stbtt_vertex **vertices) | ||
1585 | { | ||
1586 | return stbtt_GetGlyphShape(info, stbtt_FindGlyphIndex(info, unicode_codepoint), vertices); | ||
1587 | } | ||
1588 | |||
1589 | static void stbtt_setvertex(stbtt_vertex *v, stbtt_uint8 type, stbtt_int32 x, stbtt_int32 y, stbtt_int32 cx, stbtt_int32 cy) | ||
1590 | { | ||
1591 | v->type = type; | ||
1592 | v->x = (stbtt_int16) x; | ||
1593 | v->y = (stbtt_int16) y; | ||
1594 | v->cx = (stbtt_int16) cx; | ||
1595 | v->cy = (stbtt_int16) cy; | ||
1596 | } | ||
1597 | |||
1598 | static int stbtt__GetGlyfOffset(const stbtt_fontinfo *info, int glyph_index) | ||
1599 | { | ||
1600 | int g1,g2; | ||
1601 | |||
1602 | STBTT_assert(!info->cff.size); | ||
1603 | |||
1604 | if (glyph_index >= info->numGlyphs) return -1; // glyph index out of range | ||
1605 | if (info->indexToLocFormat >= 2) return -1; // unknown index->glyph map format | ||
1606 | |||
1607 | if (info->indexToLocFormat == 0) { | ||
1608 | g1 = info->glyf + ttUSHORT(info->data + info->loca + glyph_index * 2) * 2; | ||
1609 | g2 = info->glyf + ttUSHORT(info->data + info->loca + glyph_index * 2 + 2) * 2; | ||
1610 | } else { | ||
1611 | g1 = info->glyf + ttULONG (info->data + info->loca + glyph_index * 4); | ||
1612 | g2 = info->glyf + ttULONG (info->data + info->loca + glyph_index * 4 + 4); | ||
1613 | } | ||
1614 | |||
1615 | return g1==g2 ? -1 : g1; // if length is 0, return -1 | ||
1616 | } | ||
1617 | |||
1618 | static int stbtt__GetGlyphInfoT2(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1); | ||
1619 | |||
1620 | STBTT_DEF int stbtt_GetGlyphBox(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1) | ||
1621 | { | ||
1622 | if (info->cff.size) { | ||
1623 | stbtt__GetGlyphInfoT2(info, glyph_index, x0, y0, x1, y1); | ||
1624 | } else { | ||
1625 | int g = stbtt__GetGlyfOffset(info, glyph_index); | ||
1626 | if (g < 0) return 0; | ||
1627 | |||
1628 | if (x0) *x0 = ttSHORT(info->data + g + 2); | ||
1629 | if (y0) *y0 = ttSHORT(info->data + g + 4); | ||
1630 | if (x1) *x1 = ttSHORT(info->data + g + 6); | ||
1631 | if (y1) *y1 = ttSHORT(info->data + g + 8); | ||
1632 | } | ||
1633 | return 1; | ||
1634 | } | ||
1635 | |||
1636 | STBTT_DEF int stbtt_GetCodepointBox(const stbtt_fontinfo *info, int codepoint, int *x0, int *y0, int *x1, int *y1) | ||
1637 | { | ||
1638 | return stbtt_GetGlyphBox(info, stbtt_FindGlyphIndex(info,codepoint), x0,y0,x1,y1); | ||
1639 | } | ||
1640 | |||
1641 | STBTT_DEF int stbtt_IsGlyphEmpty(const stbtt_fontinfo *info, int glyph_index) | ||
1642 | { | ||
1643 | stbtt_int16 numberOfContours; | ||
1644 | int g; | ||
1645 | if (info->cff.size) | ||
1646 | return stbtt__GetGlyphInfoT2(info, glyph_index, NULL, NULL, NULL, NULL) == 0; | ||
1647 | g = stbtt__GetGlyfOffset(info, glyph_index); | ||
1648 | if (g < 0) return 1; | ||
1649 | numberOfContours = ttSHORT(info->data + g); | ||
1650 | return numberOfContours == 0; | ||
1651 | } | ||
1652 | |||
1653 | static int stbtt__close_shape(stbtt_vertex *vertices, int num_vertices, int was_off, int start_off, | ||
1654 | stbtt_int32 sx, stbtt_int32 sy, stbtt_int32 scx, stbtt_int32 scy, stbtt_int32 cx, stbtt_int32 cy) | ||
1655 | { | ||
1656 | if (start_off) { | ||
1657 | if (was_off) | ||
1658 | stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, (cx+scx)>>1, (cy+scy)>>1, cx,cy); | ||
1659 | stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, sx,sy,scx,scy); | ||
1660 | } else { | ||
1661 | if (was_off) | ||
1662 | stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve,sx,sy,cx,cy); | ||
1663 | else | ||
1664 | stbtt_setvertex(&vertices[num_vertices++], STBTT_vline,sx,sy,0,0); | ||
1665 | } | ||
1666 | return num_vertices; | ||
1667 | } | ||
1668 | |||
1669 | static int stbtt__GetGlyphShapeTT(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices) | ||
1670 | { | ||
1671 | stbtt_int16 numberOfContours; | ||
1672 | stbtt_uint8 *endPtsOfContours; | ||
1673 | stbtt_uint8 *data = info->data; | ||
1674 | stbtt_vertex *vertices=0; | ||
1675 | int num_vertices=0; | ||
1676 | int g = stbtt__GetGlyfOffset(info, glyph_index); | ||
1677 | |||
1678 | *pvertices = NULL; | ||
1679 | |||
1680 | if (g < 0) return 0; | ||
1681 | |||
1682 | numberOfContours = ttSHORT(data + g); | ||
1683 | |||
1684 | if (numberOfContours > 0) { | ||
1685 | stbtt_uint8 flags=0,flagcount; | ||
1686 | stbtt_int32 ins, i,j=0,m,n, next_move, was_off=0, off, start_off=0; | ||
1687 | stbtt_int32 x,y,cx,cy,sx,sy, scx,scy; | ||
1688 | stbtt_uint8 *points; | ||
1689 | endPtsOfContours = (data + g + 10); | ||
1690 | ins = ttUSHORT(data + g + 10 + numberOfContours * 2); | ||
1691 | points = data + g + 10 + numberOfContours * 2 + 2 + ins; | ||
1692 | |||
1693 | n = 1+ttUSHORT(endPtsOfContours + numberOfContours*2-2); | ||
1694 | |||
1695 | m = n + 2*numberOfContours; // a loose bound on how many vertices we might need | ||
1696 | vertices = (stbtt_vertex *) STBTT_malloc(m * sizeof(vertices[0]), info->userdata); | ||
1697 | if (vertices == 0) | ||
1698 | return 0; | ||
1699 | |||
1700 | next_move = 0; | ||
1701 | flagcount=0; | ||
1702 | |||
1703 | // in first pass, we load uninterpreted data into the allocated array | ||
1704 | // above, shifted to the end of the array so we won't overwrite it when | ||
1705 | // we create our final data starting from the front | ||
1706 | |||
1707 | off = m - n; // starting offset for uninterpreted data, regardless of how m ends up being calculated | ||
1708 | |||
1709 | // first load flags | ||
1710 | |||
1711 | for (i=0; i < n; ++i) { | ||
1712 | if (flagcount == 0) { | ||
1713 | flags = *points++; | ||
1714 | if (flags & 8) | ||
1715 | flagcount = *points++; | ||
1716 | } else | ||
1717 | --flagcount; | ||
1718 | vertices[off+i].type = flags; | ||
1719 | } | ||
1720 | |||
1721 | // now load x coordinates | ||
1722 | x=0; | ||
1723 | for (i=0; i < n; ++i) { | ||
1724 | flags = vertices[off+i].type; | ||
1725 | if (flags & 2) { | ||
1726 | stbtt_int16 dx = *points++; | ||
1727 | x += (flags & 16) ? dx : -dx; // ??? | ||
1728 | } else { | ||
1729 | if (!(flags & 16)) { | ||
1730 | x = x + (stbtt_int16) (points[0]*256 + points[1]); | ||
1731 | points += 2; | ||
1732 | } | ||
1733 | } | ||
1734 | vertices[off+i].x = (stbtt_int16) x; | ||
1735 | } | ||
1736 | |||
1737 | // now load y coordinates | ||
1738 | y=0; | ||
1739 | for (i=0; i < n; ++i) { | ||
1740 | flags = vertices[off+i].type; | ||
1741 | if (flags & 4) { | ||
1742 | stbtt_int16 dy = *points++; | ||
1743 | y += (flags & 32) ? dy : -dy; // ??? | ||
1744 | } else { | ||
1745 | if (!(flags & 32)) { | ||
1746 | y = y + (stbtt_int16) (points[0]*256 + points[1]); | ||
1747 | points += 2; | ||
1748 | } | ||
1749 | } | ||
1750 | vertices[off+i].y = (stbtt_int16) y; | ||
1751 | } | ||
1752 | |||
1753 | // now convert them to our format | ||
1754 | num_vertices=0; | ||
1755 | sx = sy = cx = cy = scx = scy = 0; | ||
1756 | for (i=0; i < n; ++i) { | ||
1757 | flags = vertices[off+i].type; | ||
1758 | x = (stbtt_int16) vertices[off+i].x; | ||
1759 | y = (stbtt_int16) vertices[off+i].y; | ||
1760 | |||
1761 | if (next_move == i) { | ||
1762 | if (i != 0) | ||
1763 | num_vertices = stbtt__close_shape(vertices, num_vertices, was_off, start_off, sx,sy,scx,scy,cx,cy); | ||
1764 | |||
1765 | // now start the new one | ||
1766 | start_off = !(flags & 1); | ||
1767 | if (start_off) { | ||
1768 | // if we start off with an off-curve point, then when we need to find a point on the curve | ||
1769 | // where we can start, and we need to save some state for when we wraparound. | ||
1770 | scx = x; | ||
1771 | scy = y; | ||
1772 | if (!(vertices[off+i+1].type & 1)) { | ||
1773 | // next point is also a curve point, so interpolate an on-point curve | ||
1774 | sx = (x + (stbtt_int32) vertices[off+i+1].x) >> 1; | ||
1775 | sy = (y + (stbtt_int32) vertices[off+i+1].y) >> 1; | ||
1776 | } else { | ||
1777 | // otherwise just use the next point as our start point | ||
1778 | sx = (stbtt_int32) vertices[off+i+1].x; | ||
1779 | sy = (stbtt_int32) vertices[off+i+1].y; | ||
1780 | ++i; // we're using point i+1 as the starting point, so skip it | ||
1781 | } | ||
1782 | } else { | ||
1783 | sx = x; | ||
1784 | sy = y; | ||
1785 | } | ||
1786 | stbtt_setvertex(&vertices[num_vertices++], STBTT_vmove,sx,sy,0,0); | ||
1787 | was_off = 0; | ||
1788 | next_move = 1 + ttUSHORT(endPtsOfContours+j*2); | ||
1789 | ++j; | ||
1790 | } else { | ||
1791 | if (!(flags & 1)) { // if it's a curve | ||
1792 | if (was_off) // two off-curve control points in a row means interpolate an on-curve midpoint | ||
1793 | stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, (cx+x)>>1, (cy+y)>>1, cx, cy); | ||
1794 | cx = x; | ||
1795 | cy = y; | ||
1796 | was_off = 1; | ||
1797 | } else { | ||
1798 | if (was_off) | ||
1799 | stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, x,y, cx, cy); | ||
1800 | else | ||
1801 | stbtt_setvertex(&vertices[num_vertices++], STBTT_vline, x,y,0,0); | ||
1802 | was_off = 0; | ||
1803 | } | ||
1804 | } | ||
1805 | } | ||
1806 | num_vertices = stbtt__close_shape(vertices, num_vertices, was_off, start_off, sx,sy,scx,scy,cx,cy); | ||
1807 | } else if (numberOfContours < 0) { | ||
1808 | // Compound shapes. | ||
1809 | int more = 1; | ||
1810 | stbtt_uint8 *comp = data + g + 10; | ||
1811 | num_vertices = 0; | ||
1812 | vertices = 0; | ||
1813 | while (more) { | ||
1814 | stbtt_uint16 flags, gidx; | ||
1815 | int comp_num_verts = 0, i; | ||
1816 | stbtt_vertex *comp_verts = 0, *tmp = 0; | ||
1817 | float mtx[6] = {1,0,0,1,0,0}, m, n; | ||
1818 | |||
1819 | flags = ttSHORT(comp); comp+=2; | ||
1820 | gidx = ttSHORT(comp); comp+=2; | ||
1821 | |||
1822 | if (flags & 2) { // XY values | ||
1823 | if (flags & 1) { // shorts | ||
1824 | mtx[4] = ttSHORT(comp); comp+=2; | ||
1825 | mtx[5] = ttSHORT(comp); comp+=2; | ||
1826 | } else { | ||
1827 | mtx[4] = ttCHAR(comp); comp+=1; | ||
1828 | mtx[5] = ttCHAR(comp); comp+=1; | ||
1829 | } | ||
1830 | } | ||
1831 | else { | ||
1832 | // @TODO handle matching point | ||
1833 | STBTT_assert(0); | ||
1834 | } | ||
1835 | if (flags & (1<<3)) { // WE_HAVE_A_SCALE | ||
1836 | mtx[0] = mtx[3] = ttSHORT(comp)/16384.0f; comp+=2; | ||
1837 | mtx[1] = mtx[2] = 0; | ||
1838 | } else if (flags & (1<<6)) { // WE_HAVE_AN_X_AND_YSCALE | ||
1839 | mtx[0] = ttSHORT(comp)/16384.0f; comp+=2; | ||
1840 | mtx[1] = mtx[2] = 0; | ||
1841 | mtx[3] = ttSHORT(comp)/16384.0f; comp+=2; | ||
1842 | } else if (flags & (1<<7)) { // WE_HAVE_A_TWO_BY_TWO | ||
1843 | mtx[0] = ttSHORT(comp)/16384.0f; comp+=2; | ||
1844 | mtx[1] = ttSHORT(comp)/16384.0f; comp+=2; | ||
1845 | mtx[2] = ttSHORT(comp)/16384.0f; comp+=2; | ||
1846 | mtx[3] = ttSHORT(comp)/16384.0f; comp+=2; | ||
1847 | } | ||
1848 | |||
1849 | // Find transformation scales. | ||
1850 | m = (float) STBTT_sqrt(mtx[0]*mtx[0] + mtx[1]*mtx[1]); | ||
1851 | n = (float) STBTT_sqrt(mtx[2]*mtx[2] + mtx[3]*mtx[3]); | ||
1852 | |||
1853 | // Get indexed glyph. | ||
1854 | comp_num_verts = stbtt_GetGlyphShape(info, gidx, &comp_verts); | ||
1855 | if (comp_num_verts > 0) { | ||
1856 | // Transform vertices. | ||
1857 | for (i = 0; i < comp_num_verts; ++i) { | ||
1858 | stbtt_vertex* v = &comp_verts[i]; | ||
1859 | stbtt_vertex_type x,y; | ||
1860 | x=v->x; y=v->y; | ||
1861 | v->x = (stbtt_vertex_type)(m * (mtx[0]*x + mtx[2]*y + mtx[4])); | ||
1862 | v->y = (stbtt_vertex_type)(n * (mtx[1]*x + mtx[3]*y + mtx[5])); | ||
1863 | x=v->cx; y=v->cy; | ||
1864 | v->cx = (stbtt_vertex_type)(m * (mtx[0]*x + mtx[2]*y + mtx[4])); | ||
1865 | v->cy = (stbtt_vertex_type)(n * (mtx[1]*x + mtx[3]*y + mtx[5])); | ||
1866 | } | ||
1867 | // Append vertices. | ||
1868 | tmp = (stbtt_vertex*)STBTT_malloc((num_vertices+comp_num_verts)*sizeof(stbtt_vertex), info->userdata); | ||
1869 | if (!tmp) { | ||
1870 | if (vertices) STBTT_free(vertices, info->userdata); | ||
1871 | if (comp_verts) STBTT_free(comp_verts, info->userdata); | ||
1872 | return 0; | ||
1873 | } | ||
1874 | if (num_vertices > 0) STBTT_memcpy(tmp, vertices, num_vertices*sizeof(stbtt_vertex)); | ||
1875 | STBTT_memcpy(tmp+num_vertices, comp_verts, comp_num_verts*sizeof(stbtt_vertex)); | ||
1876 | if (vertices) STBTT_free(vertices, info->userdata); | ||
1877 | vertices = tmp; | ||
1878 | STBTT_free(comp_verts, info->userdata); | ||
1879 | num_vertices += comp_num_verts; | ||
1880 | } | ||
1881 | // More components ? | ||
1882 | more = flags & (1<<5); | ||
1883 | } | ||
1884 | } else { | ||
1885 | // numberOfCounters == 0, do nothing | ||
1886 | } | ||
1887 | |||
1888 | *pvertices = vertices; | ||
1889 | return num_vertices; | ||
1890 | } | ||
1891 | |||
1892 | typedef struct | ||
1893 | { | ||
1894 | int bounds; | ||
1895 | int started; | ||
1896 | float first_x, first_y; | ||
1897 | float x, y; | ||
1898 | stbtt_int32 min_x, max_x, min_y, max_y; | ||
1899 | |||
1900 | stbtt_vertex *pvertices; | ||
1901 | int num_vertices; | ||
1902 | } stbtt__csctx; | ||
1903 | |||
1904 | #define STBTT__CSCTX_INIT(bounds) {bounds,0, 0,0, 0,0, 0,0,0,0, NULL, 0} | ||
1905 | |||
1906 | static void stbtt__track_vertex(stbtt__csctx *c, stbtt_int32 x, stbtt_int32 y) | ||
1907 | { | ||
1908 | if (x > c->max_x || !c->started) c->max_x = x; | ||
1909 | if (y > c->max_y || !c->started) c->max_y = y; | ||
1910 | if (x < c->min_x || !c->started) c->min_x = x; | ||
1911 | if (y < c->min_y || !c->started) c->min_y = y; | ||
1912 | c->started = 1; | ||
1913 | } | ||
1914 | |||
1915 | static void stbtt__csctx_v(stbtt__csctx *c, stbtt_uint8 type, stbtt_int32 x, stbtt_int32 y, stbtt_int32 cx, stbtt_int32 cy, stbtt_int32 cx1, stbtt_int32 cy1) | ||
1916 | { | ||
1917 | if (c->bounds) { | ||
1918 | stbtt__track_vertex(c, x, y); | ||
1919 | if (type == STBTT_vcubic) { | ||
1920 | stbtt__track_vertex(c, cx, cy); | ||
1921 | stbtt__track_vertex(c, cx1, cy1); | ||
1922 | } | ||
1923 | } else { | ||
1924 | stbtt_setvertex(&c->pvertices[c->num_vertices], type, x, y, cx, cy); | ||
1925 | c->pvertices[c->num_vertices].cx1 = (stbtt_int16) cx1; | ||
1926 | c->pvertices[c->num_vertices].cy1 = (stbtt_int16) cy1; | ||
1927 | } | ||
1928 | c->num_vertices++; | ||
1929 | } | ||
1930 | |||
1931 | static void stbtt__csctx_close_shape(stbtt__csctx *ctx) | ||
1932 | { | ||
1933 | if (ctx->first_x != ctx->x || ctx->first_y != ctx->y) | ||
1934 | stbtt__csctx_v(ctx, STBTT_vline, (int)ctx->first_x, (int)ctx->first_y, 0, 0, 0, 0); | ||
1935 | } | ||
1936 | |||
1937 | static void stbtt__csctx_rmove_to(stbtt__csctx *ctx, float dx, float dy) | ||
1938 | { | ||
1939 | stbtt__csctx_close_shape(ctx); | ||
1940 | ctx->first_x = ctx->x = ctx->x + dx; | ||
1941 | ctx->first_y = ctx->y = ctx->y + dy; | ||
1942 | stbtt__csctx_v(ctx, STBTT_vmove, (int)ctx->x, (int)ctx->y, 0, 0, 0, 0); | ||
1943 | } | ||
1944 | |||
1945 | static void stbtt__csctx_rline_to(stbtt__csctx *ctx, float dx, float dy) | ||
1946 | { | ||
1947 | ctx->x += dx; | ||
1948 | ctx->y += dy; | ||
1949 | stbtt__csctx_v(ctx, STBTT_vline, (int)ctx->x, (int)ctx->y, 0, 0, 0, 0); | ||
1950 | } | ||
1951 | |||
1952 | static void stbtt__csctx_rccurve_to(stbtt__csctx *ctx, float dx1, float dy1, float dx2, float dy2, float dx3, float dy3) | ||
1953 | { | ||
1954 | float cx1 = ctx->x + dx1; | ||
1955 | float cy1 = ctx->y + dy1; | ||
1956 | float cx2 = cx1 + dx2; | ||
1957 | float cy2 = cy1 + dy2; | ||
1958 | ctx->x = cx2 + dx3; | ||
1959 | ctx->y = cy2 + dy3; | ||
1960 | stbtt__csctx_v(ctx, STBTT_vcubic, (int)ctx->x, (int)ctx->y, (int)cx1, (int)cy1, (int)cx2, (int)cy2); | ||
1961 | } | ||
1962 | |||
1963 | static stbtt__buf stbtt__get_subr(stbtt__buf idx, int n) | ||
1964 | { | ||
1965 | int count = stbtt__cff_index_count(&idx); | ||
1966 | int bias = 107; | ||
1967 | if (count >= 33900) | ||
1968 | bias = 32768; | ||
1969 | else if (count >= 1240) | ||
1970 | bias = 1131; | ||
1971 | n += bias; | ||
1972 | if (n < 0 || n >= count) | ||
1973 | return stbtt__new_buf(NULL, 0); | ||
1974 | return stbtt__cff_index_get(idx, n); | ||
1975 | } | ||
1976 | |||
1977 | static stbtt__buf stbtt__cid_get_glyph_subrs(const stbtt_fontinfo *info, int glyph_index) | ||
1978 | { | ||
1979 | stbtt__buf fdselect = info->fdselect; | ||
1980 | int nranges, start, end, v, fmt, fdselector = -1, i; | ||
1981 | |||
1982 | stbtt__buf_seek(&fdselect, 0); | ||
1983 | fmt = stbtt__buf_get8(&fdselect); | ||
1984 | if (fmt == 0) { | ||
1985 | // untested | ||
1986 | stbtt__buf_skip(&fdselect, glyph_index); | ||
1987 | fdselector = stbtt__buf_get8(&fdselect); | ||
1988 | } else if (fmt == 3) { | ||
1989 | nranges = stbtt__buf_get16(&fdselect); | ||
1990 | start = stbtt__buf_get16(&fdselect); | ||
1991 | for (i = 0; i < nranges; i++) { | ||
1992 | v = stbtt__buf_get8(&fdselect); | ||
1993 | end = stbtt__buf_get16(&fdselect); | ||
1994 | if (glyph_index >= start && glyph_index < end) { | ||
1995 | fdselector = v; | ||
1996 | break; | ||
1997 | } | ||
1998 | start = end; | ||
1999 | } | ||
2000 | } | ||
2001 | if (fdselector == -1) stbtt__new_buf(NULL, 0); | ||
2002 | return stbtt__get_subrs(info->cff, stbtt__cff_index_get(info->fontdicts, fdselector)); | ||
2003 | } | ||
2004 | |||
2005 | static int stbtt__run_charstring(const stbtt_fontinfo *info, int glyph_index, stbtt__csctx *c) | ||
2006 | { | ||
2007 | int in_header = 1, maskbits = 0, subr_stack_height = 0, sp = 0, v, i, b0; | ||
2008 | int has_subrs = 0, clear_stack; | ||
2009 | float s[48]; | ||
2010 | stbtt__buf subr_stack[10], subrs = info->subrs, b; | ||
2011 | float f; | ||
2012 | |||
2013 | #define STBTT__CSERR(s) (0) | ||
2014 | |||
2015 | // this currently ignores the initial width value, which isn't needed if we have hmtx | ||
2016 | b = stbtt__cff_index_get(info->charstrings, glyph_index); | ||
2017 | while (b.cursor < b.size) { | ||
2018 | i = 0; | ||
2019 | clear_stack = 1; | ||
2020 | b0 = stbtt__buf_get8(&b); | ||
2021 | switch (b0) { | ||
2022 | // @TODO implement hinting | ||
2023 | case 0x13: // hintmask | ||
2024 | case 0x14: // cntrmask | ||
2025 | if (in_header) | ||
2026 | maskbits += (sp / 2); // implicit "vstem" | ||
2027 | in_header = 0; | ||
2028 | stbtt__buf_skip(&b, (maskbits + 7) / 8); | ||
2029 | break; | ||
2030 | |||
2031 | case 0x01: // hstem | ||
2032 | case 0x03: // vstem | ||
2033 | case 0x12: // hstemhm | ||
2034 | case 0x17: // vstemhm | ||
2035 | maskbits += (sp / 2); | ||
2036 | break; | ||
2037 | |||
2038 | case 0x15: // rmoveto | ||
2039 | in_header = 0; | ||
2040 | if (sp < 2) return STBTT__CSERR("rmoveto stack"); | ||
2041 | stbtt__csctx_rmove_to(c, s[sp-2], s[sp-1]); | ||
2042 | break; | ||
2043 | case 0x04: // vmoveto | ||
2044 | in_header = 0; | ||
2045 | if (sp < 1) return STBTT__CSERR("vmoveto stack"); | ||
2046 | stbtt__csctx_rmove_to(c, 0, s[sp-1]); | ||
2047 | break; | ||
2048 | case 0x16: // hmoveto | ||
2049 | in_header = 0; | ||
2050 | if (sp < 1) return STBTT__CSERR("hmoveto stack"); | ||
2051 | stbtt__csctx_rmove_to(c, s[sp-1], 0); | ||
2052 | break; | ||
2053 | |||
2054 | case 0x05: // rlineto | ||
2055 | if (sp < 2) return STBTT__CSERR("rlineto stack"); | ||
2056 | for (; i + 1 < sp; i += 2) | ||
2057 | stbtt__csctx_rline_to(c, s[i], s[i+1]); | ||
2058 | break; | ||
2059 | |||
2060 | // hlineto/vlineto and vhcurveto/hvcurveto alternate horizontal and vertical | ||
2061 | // starting from a different place. | ||
2062 | |||
2063 | case 0x07: // vlineto | ||
2064 | if (sp < 1) return STBTT__CSERR("vlineto stack"); | ||
2065 | goto vlineto; | ||
2066 | case 0x06: // hlineto | ||
2067 | if (sp < 1) return STBTT__CSERR("hlineto stack"); | ||
2068 | for (;;) { | ||
2069 | if (i >= sp) break; | ||
2070 | stbtt__csctx_rline_to(c, s[i], 0); | ||
2071 | i++; | ||
2072 | vlineto: | ||
2073 | if (i >= sp) break; | ||
2074 | stbtt__csctx_rline_to(c, 0, s[i]); | ||
2075 | i++; | ||
2076 | } | ||
2077 | break; | ||
2078 | |||
2079 | case 0x1F: // hvcurveto | ||
2080 | if (sp < 4) return STBTT__CSERR("hvcurveto stack"); | ||
2081 | goto hvcurveto; | ||
2082 | case 0x1E: // vhcurveto | ||
2083 | if (sp < 4) return STBTT__CSERR("vhcurveto stack"); | ||
2084 | for (;;) { | ||
2085 | if (i + 3 >= sp) break; | ||
2086 | stbtt__csctx_rccurve_to(c, 0, s[i], s[i+1], s[i+2], s[i+3], (sp - i == 5) ? s[i + 4] : 0.0f); | ||
2087 | i += 4; | ||
2088 | hvcurveto: | ||
2089 | if (i + 3 >= sp) break; | ||
2090 | stbtt__csctx_rccurve_to(c, s[i], 0, s[i+1], s[i+2], (sp - i == 5) ? s[i+4] : 0.0f, s[i+3]); | ||
2091 | i += 4; | ||
2092 | } | ||
2093 | break; | ||
2094 | |||
2095 | case 0x08: // rrcurveto | ||
2096 | if (sp < 6) return STBTT__CSERR("rcurveline stack"); | ||
2097 | for (; i + 5 < sp; i += 6) | ||
2098 | stbtt__csctx_rccurve_to(c, s[i], s[i+1], s[i+2], s[i+3], s[i+4], s[i+5]); | ||
2099 | break; | ||
2100 | |||
2101 | case 0x18: // rcurveline | ||
2102 | if (sp < 8) return STBTT__CSERR("rcurveline stack"); | ||
2103 | for (; i + 5 < sp - 2; i += 6) | ||
2104 | stbtt__csctx_rccurve_to(c, s[i], s[i+1], s[i+2], s[i+3], s[i+4], s[i+5]); | ||
2105 | if (i + 1 >= sp) return STBTT__CSERR("rcurveline stack"); | ||
2106 | stbtt__csctx_rline_to(c, s[i], s[i+1]); | ||
2107 | break; | ||
2108 | |||
2109 | case 0x19: // rlinecurve | ||
2110 | if (sp < 8) return STBTT__CSERR("rlinecurve stack"); | ||
2111 | for (; i + 1 < sp - 6; i += 2) | ||
2112 | stbtt__csctx_rline_to(c, s[i], s[i+1]); | ||
2113 | if (i + 5 >= sp) return STBTT__CSERR("rlinecurve stack"); | ||
2114 | stbtt__csctx_rccurve_to(c, s[i], s[i+1], s[i+2], s[i+3], s[i+4], s[i+5]); | ||
2115 | break; | ||
2116 | |||
2117 | case 0x1A: // vvcurveto | ||
2118 | case 0x1B: // hhcurveto | ||
2119 | if (sp < 4) return STBTT__CSERR("(vv|hh)curveto stack"); | ||
2120 | f = 0.0; | ||
2121 | if (sp & 1) { f = s[i]; i++; } | ||
2122 | for (; i + 3 < sp; i += 4) { | ||
2123 | if (b0 == 0x1B) | ||
2124 | stbtt__csctx_rccurve_to(c, s[i], f, s[i+1], s[i+2], s[i+3], 0.0); | ||
2125 | else | ||
2126 | stbtt__csctx_rccurve_to(c, f, s[i], s[i+1], s[i+2], 0.0, s[i+3]); | ||
2127 | f = 0.0; | ||
2128 | } | ||
2129 | break; | ||
2130 | |||
2131 | case 0x0A: // callsubr | ||
2132 | if (!has_subrs) { | ||
2133 | if (info->fdselect.size) | ||
2134 | subrs = stbtt__cid_get_glyph_subrs(info, glyph_index); | ||
2135 | has_subrs = 1; | ||
2136 | } | ||
2137 | // fallthrough | ||
2138 | case 0x1D: // callgsubr | ||
2139 | if (sp < 1) return STBTT__CSERR("call(g|)subr stack"); | ||
2140 | v = (int) s[--sp]; | ||
2141 | if (subr_stack_height >= 10) return STBTT__CSERR("recursion limit"); | ||
2142 | subr_stack[subr_stack_height++] = b; | ||
2143 | b = stbtt__get_subr(b0 == 0x0A ? subrs : info->gsubrs, v); | ||
2144 | if (b.size == 0) return STBTT__CSERR("subr not found"); | ||
2145 | b.cursor = 0; | ||
2146 | clear_stack = 0; | ||
2147 | break; | ||
2148 | |||
2149 | case 0x0B: // return | ||
2150 | if (subr_stack_height <= 0) return STBTT__CSERR("return outside subr"); | ||
2151 | b = subr_stack[--subr_stack_height]; | ||
2152 | clear_stack = 0; | ||
2153 | break; | ||
2154 | |||
2155 | case 0x0E: // endchar | ||
2156 | stbtt__csctx_close_shape(c); | ||
2157 | return 1; | ||
2158 | |||
2159 | case 0x0C: { // two-byte escape | ||
2160 | float dx1, dx2, dx3, dx4, dx5, dx6, dy1, dy2, dy3, dy4, dy5, dy6; | ||
2161 | float dx, dy; | ||
2162 | int b1 = stbtt__buf_get8(&b); | ||
2163 | switch (b1) { | ||
2164 | // @TODO These "flex" implementations ignore the flex-depth and resolution, | ||
2165 | // and always draw beziers. | ||
2166 | case 0x22: // hflex | ||
2167 | if (sp < 7) return STBTT__CSERR("hflex stack"); | ||
2168 | dx1 = s[0]; | ||
2169 | dx2 = s[1]; | ||
2170 | dy2 = s[2]; | ||
2171 | dx3 = s[3]; | ||
2172 | dx4 = s[4]; | ||
2173 | dx5 = s[5]; | ||
2174 | dx6 = s[6]; | ||
2175 | stbtt__csctx_rccurve_to(c, dx1, 0, dx2, dy2, dx3, 0); | ||
2176 | stbtt__csctx_rccurve_to(c, dx4, 0, dx5, -dy2, dx6, 0); | ||
2177 | break; | ||
2178 | |||
2179 | case 0x23: // flex | ||
2180 | if (sp < 13) return STBTT__CSERR("flex stack"); | ||
2181 | dx1 = s[0]; | ||
2182 | dy1 = s[1]; | ||
2183 | dx2 = s[2]; | ||
2184 | dy2 = s[3]; | ||
2185 | dx3 = s[4]; | ||
2186 | dy3 = s[5]; | ||
2187 | dx4 = s[6]; | ||
2188 | dy4 = s[7]; | ||
2189 | dx5 = s[8]; | ||
2190 | dy5 = s[9]; | ||
2191 | dx6 = s[10]; | ||
2192 | dy6 = s[11]; | ||
2193 | //fd is s[12] | ||
2194 | stbtt__csctx_rccurve_to(c, dx1, dy1, dx2, dy2, dx3, dy3); | ||
2195 | stbtt__csctx_rccurve_to(c, dx4, dy4, dx5, dy5, dx6, dy6); | ||
2196 | break; | ||
2197 | |||
2198 | case 0x24: // hflex1 | ||
2199 | if (sp < 9) return STBTT__CSERR("hflex1 stack"); | ||
2200 | dx1 = s[0]; | ||
2201 | dy1 = s[1]; | ||
2202 | dx2 = s[2]; | ||
2203 | dy2 = s[3]; | ||
2204 | dx3 = s[4]; | ||
2205 | dx4 = s[5]; | ||
2206 | dx5 = s[6]; | ||
2207 | dy5 = s[7]; | ||
2208 | dx6 = s[8]; | ||
2209 | stbtt__csctx_rccurve_to(c, dx1, dy1, dx2, dy2, dx3, 0); | ||
2210 | stbtt__csctx_rccurve_to(c, dx4, 0, dx5, dy5, dx6, -(dy1+dy2+dy5)); | ||
2211 | break; | ||
2212 | |||
2213 | case 0x25: // flex1 | ||
2214 | if (sp < 11) return STBTT__CSERR("flex1 stack"); | ||
2215 | dx1 = s[0]; | ||
2216 | dy1 = s[1]; | ||
2217 | dx2 = s[2]; | ||
2218 | dy2 = s[3]; | ||
2219 | dx3 = s[4]; | ||
2220 | dy3 = s[5]; | ||
2221 | dx4 = s[6]; | ||
2222 | dy4 = s[7]; | ||
2223 | dx5 = s[8]; | ||
2224 | dy5 = s[9]; | ||
2225 | dx6 = dy6 = s[10]; | ||
2226 | dx = dx1+dx2+dx3+dx4+dx5; | ||
2227 | dy = dy1+dy2+dy3+dy4+dy5; | ||
2228 | if (STBTT_fabs(dx) > STBTT_fabs(dy)) | ||
2229 | dy6 = -dy; | ||
2230 | else | ||
2231 | dx6 = -dx; | ||
2232 | stbtt__csctx_rccurve_to(c, dx1, dy1, dx2, dy2, dx3, dy3); | ||
2233 | stbtt__csctx_rccurve_to(c, dx4, dy4, dx5, dy5, dx6, dy6); | ||
2234 | break; | ||
2235 | |||
2236 | default: | ||
2237 | return STBTT__CSERR("unimplemented"); | ||
2238 | } | ||
2239 | } break; | ||
2240 | |||
2241 | default: | ||
2242 | if (b0 != 255 && b0 != 28 && (b0 < 32 || b0 > 254)) | ||
2243 | return STBTT__CSERR("reserved operator"); | ||
2244 | |||
2245 | // push immediate | ||
2246 | if (b0 == 255) { | ||
2247 | f = (float)(stbtt_int32)stbtt__buf_get32(&b) / 0x10000; | ||
2248 | } else { | ||
2249 | stbtt__buf_skip(&b, -1); | ||
2250 | f = (float)(stbtt_int16)stbtt__cff_int(&b); | ||
2251 | } | ||
2252 | if (sp >= 48) return STBTT__CSERR("push stack overflow"); | ||
2253 | s[sp++] = f; | ||
2254 | clear_stack = 0; | ||
2255 | break; | ||
2256 | } | ||
2257 | if (clear_stack) sp = 0; | ||
2258 | } | ||
2259 | return STBTT__CSERR("no endchar"); | ||
2260 | |||
2261 | #undef STBTT__CSERR | ||
2262 | } | ||
2263 | |||
2264 | static int stbtt__GetGlyphShapeT2(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices) | ||
2265 | { | ||
2266 | // runs the charstring twice, once to count and once to output (to avoid realloc) | ||
2267 | stbtt__csctx count_ctx = STBTT__CSCTX_INIT(1); | ||
2268 | stbtt__csctx output_ctx = STBTT__CSCTX_INIT(0); | ||
2269 | if (stbtt__run_charstring(info, glyph_index, &count_ctx)) { | ||
2270 | *pvertices = (stbtt_vertex*)STBTT_malloc(count_ctx.num_vertices*sizeof(stbtt_vertex), info->userdata); | ||
2271 | output_ctx.pvertices = *pvertices; | ||
2272 | if (stbtt__run_charstring(info, glyph_index, &output_ctx)) { | ||
2273 | STBTT_assert(output_ctx.num_vertices == count_ctx.num_vertices); | ||
2274 | return output_ctx.num_vertices; | ||
2275 | } | ||
2276 | } | ||
2277 | *pvertices = NULL; | ||
2278 | return 0; | ||
2279 | } | ||
2280 | |||
2281 | static int stbtt__GetGlyphInfoT2(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1) | ||
2282 | { | ||
2283 | stbtt__csctx c = STBTT__CSCTX_INIT(1); | ||
2284 | int r = stbtt__run_charstring(info, glyph_index, &c); | ||
2285 | if (x0) *x0 = r ? c.min_x : 0; | ||
2286 | if (y0) *y0 = r ? c.min_y : 0; | ||
2287 | if (x1) *x1 = r ? c.max_x : 0; | ||
2288 | if (y1) *y1 = r ? c.max_y : 0; | ||
2289 | return r ? c.num_vertices : 0; | ||
2290 | } | ||
2291 | |||
2292 | STBTT_DEF int stbtt_GetGlyphShape(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices) | ||
2293 | { | ||
2294 | if (!info->cff.size) | ||
2295 | return stbtt__GetGlyphShapeTT(info, glyph_index, pvertices); | ||
2296 | else | ||
2297 | return stbtt__GetGlyphShapeT2(info, glyph_index, pvertices); | ||
2298 | } | ||
2299 | |||
2300 | STBTT_DEF void stbtt_GetGlyphHMetrics(const stbtt_fontinfo *info, int glyph_index, int *advanceWidth, int *leftSideBearing) | ||
2301 | { | ||
2302 | stbtt_uint16 numOfLongHorMetrics = ttUSHORT(info->data+info->hhea + 34); | ||
2303 | if (glyph_index < numOfLongHorMetrics) { | ||
2304 | if (advanceWidth) *advanceWidth = ttSHORT(info->data + info->hmtx + 4*glyph_index); | ||
2305 | if (leftSideBearing) *leftSideBearing = ttSHORT(info->data + info->hmtx + 4*glyph_index + 2); | ||
2306 | } else { | ||
2307 | if (advanceWidth) *advanceWidth = ttSHORT(info->data + info->hmtx + 4*(numOfLongHorMetrics-1)); | ||
2308 | if (leftSideBearing) *leftSideBearing = ttSHORT(info->data + info->hmtx + 4*numOfLongHorMetrics + 2*(glyph_index - numOfLongHorMetrics)); | ||
2309 | } | ||
2310 | } | ||
2311 | |||
2312 | STBTT_DEF int stbtt_GetKerningTableLength(const stbtt_fontinfo *info) | ||
2313 | { | ||
2314 | stbtt_uint8 *data = info->data + info->kern; | ||
2315 | |||
2316 | // we only look at the first table. it must be 'horizontal' and format 0. | ||
2317 | if (!info->kern) | ||
2318 | return 0; | ||
2319 | if (ttUSHORT(data+2) < 1) // number of tables, need at least 1 | ||
2320 | return 0; | ||
2321 | if (ttUSHORT(data+8) != 1) // horizontal flag must be set in format | ||
2322 | return 0; | ||
2323 | |||
2324 | return ttUSHORT(data+10); | ||
2325 | } | ||
2326 | |||
2327 | STBTT_DEF int stbtt_GetKerningTable(const stbtt_fontinfo *info, stbtt_kerningentry* table, int table_length) | ||
2328 | { | ||
2329 | stbtt_uint8 *data = info->data + info->kern; | ||
2330 | int k, length; | ||
2331 | |||
2332 | // we only look at the first table. it must be 'horizontal' and format 0. | ||
2333 | if (!info->kern) | ||
2334 | return 0; | ||
2335 | if (ttUSHORT(data+2) < 1) // number of tables, need at least 1 | ||
2336 | return 0; | ||
2337 | if (ttUSHORT(data+8) != 1) // horizontal flag must be set in format | ||
2338 | return 0; | ||
2339 | |||
2340 | length = ttUSHORT(data+10); | ||
2341 | if (table_length < length) | ||
2342 | length = table_length; | ||
2343 | |||
2344 | for (k = 0; k < length; k++) | ||
2345 | { | ||
2346 | table[k].glyph1 = ttUSHORT(data+18+(k*6)); | ||
2347 | table[k].glyph2 = ttUSHORT(data+20+(k*6)); | ||
2348 | table[k].advance = ttSHORT(data+22+(k*6)); | ||
2349 | } | ||
2350 | |||
2351 | return length; | ||
2352 | } | ||
2353 | |||
2354 | static int stbtt__GetGlyphKernInfoAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2) | ||
2355 | { | ||
2356 | stbtt_uint8 *data = info->data + info->kern; | ||
2357 | stbtt_uint32 needle, straw; | ||
2358 | int l, r, m; | ||
2359 | |||
2360 | // we only look at the first table. it must be 'horizontal' and format 0. | ||
2361 | if (!info->kern) | ||
2362 | return 0; | ||
2363 | if (ttUSHORT(data+2) < 1) // number of tables, need at least 1 | ||
2364 | return 0; | ||
2365 | if (ttUSHORT(data+8) != 1) // horizontal flag must be set in format | ||
2366 | return 0; | ||
2367 | |||
2368 | l = 0; | ||
2369 | r = ttUSHORT(data+10) - 1; | ||
2370 | needle = glyph1 << 16 | glyph2; | ||
2371 | while (l <= r) { | ||
2372 | m = (l + r) >> 1; | ||
2373 | straw = ttULONG(data+18+(m*6)); // note: unaligned read | ||
2374 | if (needle < straw) | ||
2375 | r = m - 1; | ||
2376 | else if (needle > straw) | ||
2377 | l = m + 1; | ||
2378 | else | ||
2379 | return ttSHORT(data+22+(m*6)); | ||
2380 | } | ||
2381 | return 0; | ||
2382 | } | ||
2383 | |||
2384 | static stbtt_int32 stbtt__GetCoverageIndex(stbtt_uint8 *coverageTable, int glyph) | ||
2385 | { | ||
2386 | stbtt_uint16 coverageFormat = ttUSHORT(coverageTable); | ||
2387 | switch(coverageFormat) { | ||
2388 | case 1: { | ||
2389 | stbtt_uint16 glyphCount = ttUSHORT(coverageTable + 2); | ||
2390 | |||
2391 | // Binary search. | ||
2392 | stbtt_int32 l=0, r=glyphCount-1, m; | ||
2393 | int straw, needle=glyph; | ||
2394 | while (l <= r) { | ||
2395 | stbtt_uint8 *glyphArray = coverageTable + 4; | ||
2396 | stbtt_uint16 glyphID; | ||
2397 | m = (l + r) >> 1; | ||
2398 | glyphID = ttUSHORT(glyphArray + 2 * m); | ||
2399 | straw = glyphID; | ||
2400 | if (needle < straw) | ||
2401 | r = m - 1; | ||
2402 | else if (needle > straw) | ||
2403 | l = m + 1; | ||
2404 | else { | ||
2405 | return m; | ||
2406 | } | ||
2407 | } | ||
2408 | } break; | ||
2409 | |||
2410 | case 2: { | ||
2411 | stbtt_uint16 rangeCount = ttUSHORT(coverageTable + 2); | ||
2412 | stbtt_uint8 *rangeArray = coverageTable + 4; | ||
2413 | |||
2414 | // Binary search. | ||
2415 | stbtt_int32 l=0, r=rangeCount-1, m; | ||
2416 | int strawStart, strawEnd, needle=glyph; | ||
2417 | while (l <= r) { | ||
2418 | stbtt_uint8 *rangeRecord; | ||
2419 | m = (l + r) >> 1; | ||
2420 | rangeRecord = rangeArray + 6 * m; | ||
2421 | strawStart = ttUSHORT(rangeRecord); | ||
2422 | strawEnd = ttUSHORT(rangeRecord + 2); | ||
2423 | if (needle < strawStart) | ||
2424 | r = m - 1; | ||
2425 | else if (needle > strawEnd) | ||
2426 | l = m + 1; | ||
2427 | else { | ||
2428 | stbtt_uint16 startCoverageIndex = ttUSHORT(rangeRecord + 4); | ||
2429 | return startCoverageIndex + glyph - strawStart; | ||
2430 | } | ||
2431 | } | ||
2432 | } break; | ||
2433 | |||
2434 | default: { | ||
2435 | // There are no other cases. | ||
2436 | STBTT_assert(0); | ||
2437 | } break; | ||
2438 | } | ||
2439 | |||
2440 | return -1; | ||
2441 | } | ||
2442 | |||
2443 | static stbtt_int32 stbtt__GetGlyphClass(stbtt_uint8 *classDefTable, int glyph) | ||
2444 | { | ||
2445 | stbtt_uint16 classDefFormat = ttUSHORT(classDefTable); | ||
2446 | switch(classDefFormat) | ||
2447 | { | ||
2448 | case 1: { | ||
2449 | stbtt_uint16 startGlyphID = ttUSHORT(classDefTable + 2); | ||
2450 | stbtt_uint16 glyphCount = ttUSHORT(classDefTable + 4); | ||
2451 | stbtt_uint8 *classDef1ValueArray = classDefTable + 6; | ||
2452 | |||
2453 | if (glyph >= startGlyphID && glyph < startGlyphID + glyphCount) | ||
2454 | return (stbtt_int32)ttUSHORT(classDef1ValueArray + 2 * (glyph - startGlyphID)); | ||
2455 | |||
2456 | classDefTable = classDef1ValueArray + 2 * glyphCount; | ||
2457 | } break; | ||
2458 | |||
2459 | case 2: { | ||
2460 | stbtt_uint16 classRangeCount = ttUSHORT(classDefTable + 2); | ||
2461 | stbtt_uint8 *classRangeRecords = classDefTable + 4; | ||
2462 | |||
2463 | // Binary search. | ||
2464 | stbtt_int32 l=0, r=classRangeCount-1, m; | ||
2465 | int strawStart, strawEnd, needle=glyph; | ||
2466 | while (l <= r) { | ||
2467 | stbtt_uint8 *classRangeRecord; | ||
2468 | m = (l + r) >> 1; | ||
2469 | classRangeRecord = classRangeRecords + 6 * m; | ||
2470 | strawStart = ttUSHORT(classRangeRecord); | ||
2471 | strawEnd = ttUSHORT(classRangeRecord + 2); | ||
2472 | if (needle < strawStart) | ||
2473 | r = m - 1; | ||
2474 | else if (needle > strawEnd) | ||
2475 | l = m + 1; | ||
2476 | else | ||
2477 | return (stbtt_int32)ttUSHORT(classRangeRecord + 4); | ||
2478 | } | ||
2479 | |||
2480 | classDefTable = classRangeRecords + 6 * classRangeCount; | ||
2481 | } break; | ||
2482 | |||
2483 | default: { | ||
2484 | // There are no other cases. | ||
2485 | STBTT_assert(0); | ||
2486 | } break; | ||
2487 | } | ||
2488 | |||
2489 | return -1; | ||
2490 | } | ||
2491 | |||
2492 | // Define to STBTT_assert(x) if you want to break on unimplemented formats. | ||
2493 | #define STBTT_GPOS_TODO_assert(x) | ||
2494 | |||
2495 | static stbtt_int32 stbtt__GetGlyphGPOSInfoAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2) | ||
2496 | { | ||
2497 | stbtt_uint16 lookupListOffset; | ||
2498 | stbtt_uint8 *lookupList; | ||
2499 | stbtt_uint16 lookupCount; | ||
2500 | stbtt_uint8 *data; | ||
2501 | stbtt_int32 i; | ||
2502 | |||
2503 | if (!info->gpos) return 0; | ||
2504 | |||
2505 | data = info->data + info->gpos; | ||
2506 | |||
2507 | if (ttUSHORT(data+0) != 1) return 0; // Major version 1 | ||
2508 | if (ttUSHORT(data+2) != 0) return 0; // Minor version 0 | ||
2509 | |||
2510 | lookupListOffset = ttUSHORT(data+8); | ||
2511 | lookupList = data + lookupListOffset; | ||
2512 | lookupCount = ttUSHORT(lookupList); | ||
2513 | |||
2514 | for (i=0; i<lookupCount; ++i) { | ||
2515 | stbtt_uint16 lookupOffset = ttUSHORT(lookupList + 2 + 2 * i); | ||
2516 | stbtt_uint8 *lookupTable = lookupList + lookupOffset; | ||
2517 | |||
2518 | stbtt_uint16 lookupType = ttUSHORT(lookupTable); | ||
2519 | stbtt_uint16 subTableCount = ttUSHORT(lookupTable + 4); | ||
2520 | stbtt_uint8 *subTableOffsets = lookupTable + 6; | ||
2521 | switch(lookupType) { | ||
2522 | case 2: { // Pair Adjustment Positioning Subtable | ||
2523 | stbtt_int32 sti; | ||
2524 | for (sti=0; sti<subTableCount; sti++) { | ||
2525 | stbtt_uint16 subtableOffset = ttUSHORT(subTableOffsets + 2 * sti); | ||
2526 | stbtt_uint8 *table = lookupTable + subtableOffset; | ||
2527 | stbtt_uint16 posFormat = ttUSHORT(table); | ||
2528 | stbtt_uint16 coverageOffset = ttUSHORT(table + 2); | ||
2529 | stbtt_int32 coverageIndex = stbtt__GetCoverageIndex(table + coverageOffset, glyph1); | ||
2530 | if (coverageIndex == -1) continue; | ||
2531 | |||
2532 | switch (posFormat) { | ||
2533 | case 1: { | ||
2534 | stbtt_int32 l, r, m; | ||
2535 | int straw, needle; | ||
2536 | stbtt_uint16 valueFormat1 = ttUSHORT(table + 4); | ||
2537 | stbtt_uint16 valueFormat2 = ttUSHORT(table + 6); | ||
2538 | stbtt_int32 valueRecordPairSizeInBytes = 2; | ||
2539 | stbtt_uint16 pairSetCount = ttUSHORT(table + 8); | ||
2540 | stbtt_uint16 pairPosOffset = ttUSHORT(table + 10 + 2 * coverageIndex); | ||
2541 | stbtt_uint8 *pairValueTable = table + pairPosOffset; | ||
2542 | stbtt_uint16 pairValueCount = ttUSHORT(pairValueTable); | ||
2543 | stbtt_uint8 *pairValueArray = pairValueTable + 2; | ||
2544 | // TODO: Support more formats. | ||
2545 | STBTT_GPOS_TODO_assert(valueFormat1 == 4); | ||
2546 | if (valueFormat1 != 4) return 0; | ||
2547 | STBTT_GPOS_TODO_assert(valueFormat2 == 0); | ||
2548 | if (valueFormat2 != 0) return 0; | ||
2549 | |||
2550 | STBTT_assert(coverageIndex < pairSetCount); | ||
2551 | STBTT__NOTUSED(pairSetCount); | ||
2552 | |||
2553 | needle=glyph2; | ||
2554 | r=pairValueCount-1; | ||
2555 | l=0; | ||
2556 | |||
2557 | // Binary search. | ||
2558 | while (l <= r) { | ||
2559 | stbtt_uint16 secondGlyph; | ||
2560 | stbtt_uint8 *pairValue; | ||
2561 | m = (l + r) >> 1; | ||
2562 | pairValue = pairValueArray + (2 + valueRecordPairSizeInBytes) * m; | ||
2563 | secondGlyph = ttUSHORT(pairValue); | ||
2564 | straw = secondGlyph; | ||
2565 | if (needle < straw) | ||
2566 | r = m - 1; | ||
2567 | else if (needle > straw) | ||
2568 | l = m + 1; | ||
2569 | else { | ||
2570 | stbtt_int16 xAdvance = ttSHORT(pairValue + 2); | ||
2571 | return xAdvance; | ||
2572 | } | ||
2573 | } | ||
2574 | } break; | ||
2575 | |||
2576 | case 2: { | ||
2577 | stbtt_uint16 valueFormat1 = ttUSHORT(table + 4); | ||
2578 | stbtt_uint16 valueFormat2 = ttUSHORT(table + 6); | ||
2579 | |||
2580 | stbtt_uint16 classDef1Offset = ttUSHORT(table + 8); | ||
2581 | stbtt_uint16 classDef2Offset = ttUSHORT(table + 10); | ||
2582 | int glyph1class = stbtt__GetGlyphClass(table + classDef1Offset, glyph1); | ||
2583 | int glyph2class = stbtt__GetGlyphClass(table + classDef2Offset, glyph2); | ||
2584 | |||
2585 | stbtt_uint16 class1Count = ttUSHORT(table + 12); | ||
2586 | stbtt_uint16 class2Count = ttUSHORT(table + 14); | ||
2587 | STBTT_assert(glyph1class < class1Count); | ||
2588 | STBTT_assert(glyph2class < class2Count); | ||
2589 | |||
2590 | // TODO: Support more formats. | ||
2591 | STBTT_GPOS_TODO_assert(valueFormat1 == 4); | ||
2592 | if (valueFormat1 != 4) return 0; | ||
2593 | STBTT_GPOS_TODO_assert(valueFormat2 == 0); | ||
2594 | if (valueFormat2 != 0) return 0; | ||
2595 | |||
2596 | if (glyph1class >= 0 && glyph1class < class1Count && glyph2class >= 0 && glyph2class < class2Count) { | ||
2597 | stbtt_uint8 *class1Records = table + 16; | ||
2598 | stbtt_uint8 *class2Records = class1Records + 2 * (glyph1class * class2Count); | ||
2599 | stbtt_int16 xAdvance = ttSHORT(class2Records + 2 * glyph2class); | ||
2600 | return xAdvance; | ||
2601 | } | ||
2602 | } break; | ||
2603 | |||
2604 | default: { | ||
2605 | // There are no other cases. | ||
2606 | STBTT_assert(0); | ||
2607 | break; | ||
2608 | }; | ||
2609 | } | ||
2610 | } | ||
2611 | break; | ||
2612 | }; | ||
2613 | |||
2614 | default: | ||
2615 | // TODO: Implement other stuff. | ||
2616 | break; | ||
2617 | } | ||
2618 | } | ||
2619 | |||
2620 | return 0; | ||
2621 | } | ||
2622 | |||
2623 | STBTT_DEF int stbtt_GetGlyphKernAdvance(const stbtt_fontinfo *info, int g1, int g2) | ||
2624 | { | ||
2625 | int xAdvance = 0; | ||
2626 | |||
2627 | if (info->gpos) | ||
2628 | xAdvance += stbtt__GetGlyphGPOSInfoAdvance(info, g1, g2); | ||
2629 | else if (info->kern) | ||
2630 | xAdvance += stbtt__GetGlyphKernInfoAdvance(info, g1, g2); | ||
2631 | |||
2632 | return xAdvance; | ||
2633 | } | ||
2634 | |||
2635 | STBTT_DEF int stbtt_GetCodepointKernAdvance(const stbtt_fontinfo *info, int ch1, int ch2) | ||
2636 | { | ||
2637 | if (!info->kern && !info->gpos) // if no kerning table, don't waste time looking up both codepoint->glyphs | ||
2638 | return 0; | ||
2639 | return stbtt_GetGlyphKernAdvance(info, stbtt_FindGlyphIndex(info,ch1), stbtt_FindGlyphIndex(info,ch2)); | ||
2640 | } | ||
2641 | |||
2642 | STBTT_DEF void stbtt_GetCodepointHMetrics(const stbtt_fontinfo *info, int codepoint, int *advanceWidth, int *leftSideBearing) | ||
2643 | { | ||
2644 | stbtt_GetGlyphHMetrics(info, stbtt_FindGlyphIndex(info,codepoint), advanceWidth, leftSideBearing); | ||
2645 | } | ||
2646 | |||
2647 | STBTT_DEF void stbtt_GetFontVMetrics(const stbtt_fontinfo *info, int *ascent, int *descent, int *lineGap) | ||
2648 | { | ||
2649 | if (ascent ) *ascent = ttSHORT(info->data+info->hhea + 4); | ||
2650 | if (descent) *descent = ttSHORT(info->data+info->hhea + 6); | ||
2651 | if (lineGap) *lineGap = ttSHORT(info->data+info->hhea + 8); | ||
2652 | } | ||
2653 | |||
2654 | STBTT_DEF int stbtt_GetFontVMetricsOS2(const stbtt_fontinfo *info, int *typoAscent, int *typoDescent, int *typoLineGap) | ||
2655 | { | ||
2656 | int tab = stbtt__find_table(info->data, info->fontstart, "OS/2"); | ||
2657 | if (!tab) | ||
2658 | return 0; | ||
2659 | if (typoAscent ) *typoAscent = ttSHORT(info->data+tab + 68); | ||
2660 | if (typoDescent) *typoDescent = ttSHORT(info->data+tab + 70); | ||
2661 | if (typoLineGap) *typoLineGap = ttSHORT(info->data+tab + 72); | ||
2662 | return 1; | ||
2663 | } | ||
2664 | |||
2665 | STBTT_DEF void stbtt_GetFontBoundingBox(const stbtt_fontinfo *info, int *x0, int *y0, int *x1, int *y1) | ||
2666 | { | ||
2667 | *x0 = ttSHORT(info->data + info->head + 36); | ||
2668 | *y0 = ttSHORT(info->data + info->head + 38); | ||
2669 | *x1 = ttSHORT(info->data + info->head + 40); | ||
2670 | *y1 = ttSHORT(info->data + info->head + 42); | ||
2671 | } | ||
2672 | |||
2673 | STBTT_DEF float stbtt_ScaleForPixelHeight(const stbtt_fontinfo *info, float height) | ||
2674 | { | ||
2675 | int fheight = ttSHORT(info->data + info->hhea + 4) - ttSHORT(info->data + info->hhea + 6); | ||
2676 | return (float) height / fheight; | ||
2677 | } | ||
2678 | |||
2679 | STBTT_DEF float stbtt_ScaleForMappingEmToPixels(const stbtt_fontinfo *info, float pixels) | ||
2680 | { | ||
2681 | int unitsPerEm = ttUSHORT(info->data + info->head + 18); | ||
2682 | return pixels / unitsPerEm; | ||
2683 | } | ||
2684 | |||
2685 | STBTT_DEF void stbtt_FreeShape(const stbtt_fontinfo *info, stbtt_vertex *v) | ||
2686 | { | ||
2687 | STBTT_free(v, info->userdata); | ||
2688 | } | ||
2689 | |||
2690 | STBTT_DEF stbtt_uint8 *stbtt_FindSVGDoc(const stbtt_fontinfo *info, int gl) | ||
2691 | { | ||
2692 | int i; | ||
2693 | stbtt_uint8 *data = info->data; | ||
2694 | stbtt_uint8 *svg_doc_list = data + stbtt__get_svg((stbtt_fontinfo *) info); | ||
2695 | |||
2696 | int numEntries = ttUSHORT(svg_doc_list); | ||
2697 | stbtt_uint8 *svg_docs = svg_doc_list + 2; | ||
2698 | |||
2699 | for(i=0; i<numEntries; i++) { | ||
2700 | stbtt_uint8 *svg_doc = svg_docs + (12 * i); | ||
2701 | if ((gl >= ttUSHORT(svg_doc)) && (gl <= ttUSHORT(svg_doc + 2))) | ||
2702 | return svg_doc; | ||
2703 | } | ||
2704 | return 0; | ||
2705 | } | ||
2706 | |||
2707 | STBTT_DEF int stbtt_GetGlyphSVG(const stbtt_fontinfo *info, int gl, const char **svg) | ||
2708 | { | ||
2709 | stbtt_uint8 *data = info->data; | ||
2710 | stbtt_uint8 *svg_doc; | ||
2711 | |||
2712 | if (info->svg == 0) | ||
2713 | return 0; | ||
2714 | |||
2715 | svg_doc = stbtt_FindSVGDoc(info, gl); | ||
2716 | if (svg_doc != NULL) { | ||
2717 | *svg = (char *) data + info->svg + ttULONG(svg_doc + 4); | ||
2718 | return ttULONG(svg_doc + 8); | ||
2719 | } else { | ||
2720 | return 0; | ||
2721 | } | ||
2722 | } | ||
2723 | |||
2724 | STBTT_DEF int stbtt_GetCodepointSVG(const stbtt_fontinfo *info, int unicode_codepoint, const char **svg) | ||
2725 | { | ||
2726 | return stbtt_GetGlyphSVG(info, stbtt_FindGlyphIndex(info, unicode_codepoint), svg); | ||
2727 | } | ||
2728 | |||
2729 | ////////////////////////////////////////////////////////////////////////////// | ||
2730 | // | ||
2731 | // antialiasing software rasterizer | ||
2732 | // | ||
2733 | |||
2734 | STBTT_DEF void stbtt_GetGlyphBitmapBoxSubpixel(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y,float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1) | ||
2735 | { | ||
2736 | int x0=0,y0=0,x1,y1; // =0 suppresses compiler warning | ||
2737 | if (!stbtt_GetGlyphBox(font, glyph, &x0,&y0,&x1,&y1)) { | ||
2738 | // e.g. space character | ||
2739 | if (ix0) *ix0 = 0; | ||
2740 | if (iy0) *iy0 = 0; | ||
2741 | if (ix1) *ix1 = 0; | ||
2742 | if (iy1) *iy1 = 0; | ||
2743 | } else { | ||
2744 | // move to integral bboxes (treating pixels as little squares, what pixels get touched)? | ||
2745 | if (ix0) *ix0 = STBTT_ifloor( x0 * scale_x + shift_x); | ||
2746 | if (iy0) *iy0 = STBTT_ifloor(-y1 * scale_y + shift_y); | ||
2747 | if (ix1) *ix1 = STBTT_iceil ( x1 * scale_x + shift_x); | ||
2748 | if (iy1) *iy1 = STBTT_iceil (-y0 * scale_y + shift_y); | ||
2749 | } | ||
2750 | } | ||
2751 | |||
2752 | STBTT_DEF void stbtt_GetGlyphBitmapBox(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1) | ||
2753 | { | ||
2754 | stbtt_GetGlyphBitmapBoxSubpixel(font, glyph, scale_x, scale_y,0.0f,0.0f, ix0, iy0, ix1, iy1); | ||
2755 | } | ||
2756 | |||
2757 | STBTT_DEF void stbtt_GetCodepointBitmapBoxSubpixel(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1) | ||
2758 | { | ||
2759 | stbtt_GetGlyphBitmapBoxSubpixel(font, stbtt_FindGlyphIndex(font,codepoint), scale_x, scale_y,shift_x,shift_y, ix0,iy0,ix1,iy1); | ||
2760 | } | ||
2761 | |||
2762 | STBTT_DEF void stbtt_GetCodepointBitmapBox(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1) | ||
2763 | { | ||
2764 | stbtt_GetCodepointBitmapBoxSubpixel(font, codepoint, scale_x, scale_y,0.0f,0.0f, ix0,iy0,ix1,iy1); | ||
2765 | } | ||
2766 | |||
2767 | ////////////////////////////////////////////////////////////////////////////// | ||
2768 | // | ||
2769 | // Rasterizer | ||
2770 | |||
2771 | typedef struct stbtt__hheap_chunk | ||
2772 | { | ||
2773 | struct stbtt__hheap_chunk *next; | ||
2774 | } stbtt__hheap_chunk; | ||
2775 | |||
2776 | typedef struct stbtt__hheap | ||
2777 | { | ||
2778 | struct stbtt__hheap_chunk *head; | ||
2779 | void *first_free; | ||
2780 | int num_remaining_in_head_chunk; | ||
2781 | } stbtt__hheap; | ||
2782 | |||
2783 | static void *stbtt__hheap_alloc(stbtt__hheap *hh, size_t size, void *userdata) | ||
2784 | { | ||
2785 | if (hh->first_free) { | ||
2786 | void *p = hh->first_free; | ||
2787 | hh->first_free = * (void **) p; | ||
2788 | return p; | ||
2789 | } else { | ||
2790 | if (hh->num_remaining_in_head_chunk == 0) { | ||
2791 | int count = (size < 32 ? 2000 : size < 128 ? 800 : 100); | ||
2792 | stbtt__hheap_chunk *c = (stbtt__hheap_chunk *) STBTT_malloc(sizeof(stbtt__hheap_chunk) + size * count, userdata); | ||
2793 | if (c == NULL) | ||
2794 | return NULL; | ||
2795 | c->next = hh->head; | ||
2796 | hh->head = c; | ||
2797 | hh->num_remaining_in_head_chunk = count; | ||
2798 | } | ||
2799 | --hh->num_remaining_in_head_chunk; | ||
2800 | return (char *) (hh->head) + sizeof(stbtt__hheap_chunk) + size * hh->num_remaining_in_head_chunk; | ||
2801 | } | ||
2802 | } | ||
2803 | |||
2804 | static void stbtt__hheap_free(stbtt__hheap *hh, void *p) | ||
2805 | { | ||
2806 | *(void **) p = hh->first_free; | ||
2807 | hh->first_free = p; | ||
2808 | } | ||
2809 | |||
2810 | static void stbtt__hheap_cleanup(stbtt__hheap *hh, void *userdata) | ||
2811 | { | ||
2812 | stbtt__hheap_chunk *c = hh->head; | ||
2813 | while (c) { | ||
2814 | stbtt__hheap_chunk *n = c->next; | ||
2815 | STBTT_free(c, userdata); | ||
2816 | c = n; | ||
2817 | } | ||
2818 | } | ||
2819 | |||
2820 | typedef struct stbtt__edge { | ||
2821 | float x0,y0, x1,y1; | ||
2822 | int invert; | ||
2823 | } stbtt__edge; | ||
2824 | |||
2825 | |||
2826 | typedef struct stbtt__active_edge | ||
2827 | { | ||
2828 | struct stbtt__active_edge *next; | ||
2829 | #if STBTT_RASTERIZER_VERSION==1 | ||
2830 | int x,dx; | ||
2831 | float ey; | ||
2832 | int direction; | ||
2833 | #elif STBTT_RASTERIZER_VERSION==2 | ||
2834 | float fx,fdx,fdy; | ||
2835 | float direction; | ||
2836 | float sy; | ||
2837 | float ey; | ||
2838 | #else | ||
2839 | #error "Unrecognized value of STBTT_RASTERIZER_VERSION" | ||
2840 | #endif | ||
2841 | } stbtt__active_edge; | ||
2842 | |||
2843 | #if STBTT_RASTERIZER_VERSION == 1 | ||
2844 | #define STBTT_FIXSHIFT 10 | ||
2845 | #define STBTT_FIX (1 << STBTT_FIXSHIFT) | ||
2846 | #define STBTT_FIXMASK (STBTT_FIX-1) | ||
2847 | |||
2848 | static stbtt__active_edge *stbtt__new_active(stbtt__hheap *hh, stbtt__edge *e, int off_x, float start_point, void *userdata) | ||
2849 | { | ||
2850 | stbtt__active_edge *z = (stbtt__active_edge *) stbtt__hheap_alloc(hh, sizeof(*z), userdata); | ||
2851 | float dxdy = (e->x1 - e->x0) / (e->y1 - e->y0); | ||
2852 | STBTT_assert(z != NULL); | ||
2853 | if (!z) return z; | ||
2854 | |||
2855 | // round dx down to avoid overshooting | ||
2856 | if (dxdy < 0) | ||
2857 | z->dx = -STBTT_ifloor(STBTT_FIX * -dxdy); | ||
2858 | else | ||
2859 | z->dx = STBTT_ifloor(STBTT_FIX * dxdy); | ||
2860 | |||
2861 | z->x = STBTT_ifloor(STBTT_FIX * e->x0 + z->dx * (start_point - e->y0)); // use z->dx so when we offset later it's by the same amount | ||
2862 | z->x -= off_x * STBTT_FIX; | ||
2863 | |||
2864 | z->ey = e->y1; | ||
2865 | z->next = 0; | ||
2866 | z->direction = e->invert ? 1 : -1; | ||
2867 | return z; | ||
2868 | } | ||
2869 | #elif STBTT_RASTERIZER_VERSION == 2 | ||
2870 | static stbtt__active_edge *stbtt__new_active(stbtt__hheap *hh, stbtt__edge *e, int off_x, float start_point, void *userdata) | ||
2871 | { | ||
2872 | stbtt__active_edge *z = (stbtt__active_edge *) stbtt__hheap_alloc(hh, sizeof(*z), userdata); | ||
2873 | float dxdy = (e->x1 - e->x0) / (e->y1 - e->y0); | ||
2874 | STBTT_assert(z != NULL); | ||
2875 | //STBTT_assert(e->y0 <= start_point); | ||
2876 | if (!z) return z; | ||
2877 | z->fdx = dxdy; | ||
2878 | z->fdy = dxdy != 0.0f ? (1.0f/dxdy) : 0.0f; | ||
2879 | z->fx = e->x0 + dxdy * (start_point - e->y0); | ||
2880 | z->fx -= off_x; | ||
2881 | z->direction = e->invert ? 1.0f : -1.0f; | ||
2882 | z->sy = e->y0; | ||
2883 | z->ey = e->y1; | ||
2884 | z->next = 0; | ||
2885 | return z; | ||
2886 | } | ||
2887 | #else | ||
2888 | #error "Unrecognized value of STBTT_RASTERIZER_VERSION" | ||
2889 | #endif | ||
2890 | |||
2891 | #if STBTT_RASTERIZER_VERSION == 1 | ||
2892 | // note: this routine clips fills that extend off the edges... ideally this | ||
2893 | // wouldn't happen, but it could happen if the truetype glyph bounding boxes | ||
2894 | // are wrong, or if the user supplies a too-small bitmap | ||
2895 | static void stbtt__fill_active_edges(unsigned char *scanline, int len, stbtt__active_edge *e, int max_weight) | ||
2896 | { | ||
2897 | // non-zero winding fill | ||
2898 | int x0=0, w=0; | ||
2899 | |||
2900 | while (e) { | ||
2901 | if (w == 0) { | ||
2902 | // if we're currently at zero, we need to record the edge start point | ||
2903 | x0 = e->x; w += e->direction; | ||
2904 | } else { | ||
2905 | int x1 = e->x; w += e->direction; | ||
2906 | // if we went to zero, we need to draw | ||
2907 | if (w == 0) { | ||
2908 | int i = x0 >> STBTT_FIXSHIFT; | ||
2909 | int j = x1 >> STBTT_FIXSHIFT; | ||
2910 | |||
2911 | if (i < len && j >= 0) { | ||
2912 | if (i == j) { | ||
2913 | // x0,x1 are the same pixel, so compute combined coverage | ||
2914 | scanline[i] = scanline[i] + (stbtt_uint8) ((x1 - x0) * max_weight >> STBTT_FIXSHIFT); | ||
2915 | } else { | ||
2916 | if (i >= 0) // add antialiasing for x0 | ||
2917 | scanline[i] = scanline[i] + (stbtt_uint8) (((STBTT_FIX - (x0 & STBTT_FIXMASK)) * max_weight) >> STBTT_FIXSHIFT); | ||
2918 | else | ||
2919 | i = -1; // clip | ||
2920 | |||
2921 | if (j < len) // add antialiasing for x1 | ||
2922 | scanline[j] = scanline[j] + (stbtt_uint8) (((x1 & STBTT_FIXMASK) * max_weight) >> STBTT_FIXSHIFT); | ||
2923 | else | ||
2924 | j = len; // clip | ||
2925 | |||
2926 | for (++i; i < j; ++i) // fill pixels between x0 and x1 | ||
2927 | scanline[i] = scanline[i] + (stbtt_uint8) max_weight; | ||
2928 | } | ||
2929 | } | ||
2930 | } | ||
2931 | } | ||
2932 | |||
2933 | e = e->next; | ||
2934 | } | ||
2935 | } | ||
2936 | |||
2937 | static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e, int n, int vsubsample, int off_x, int off_y, void *userdata) | ||
2938 | { | ||
2939 | stbtt__hheap hh = { 0, 0, 0 }; | ||
2940 | stbtt__active_edge *active = NULL; | ||
2941 | int y,j=0; | ||
2942 | int max_weight = (255 / vsubsample); // weight per vertical scanline | ||
2943 | int s; // vertical subsample index | ||
2944 | unsigned char scanline_data[512], *scanline; | ||
2945 | |||
2946 | if (result->w > 512) | ||
2947 | scanline = (unsigned char *) STBTT_malloc(result->w, userdata); | ||
2948 | else | ||
2949 | scanline = scanline_data; | ||
2950 | |||
2951 | y = off_y * vsubsample; | ||
2952 | e[n].y0 = (off_y + result->h) * (float) vsubsample + 1; | ||
2953 | |||
2954 | while (j < result->h) { | ||
2955 | STBTT_memset(scanline, 0, result->w); | ||
2956 | for (s=0; s < vsubsample; ++s) { | ||
2957 | // find center of pixel for this scanline | ||
2958 | float scan_y = y + 0.5f; | ||
2959 | stbtt__active_edge **step = &active; | ||
2960 | |||
2961 | // update all active edges; | ||
2962 | // remove all active edges that terminate before the center of this scanline | ||
2963 | while (*step) { | ||
2964 | stbtt__active_edge * z = *step; | ||
2965 | if (z->ey <= scan_y) { | ||
2966 | *step = z->next; // delete from list | ||
2967 | STBTT_assert(z->direction); | ||
2968 | z->direction = 0; | ||
2969 | stbtt__hheap_free(&hh, z); | ||
2970 | } else { | ||
2971 | z->x += z->dx; // advance to position for current scanline | ||
2972 | step = &((*step)->next); // advance through list | ||
2973 | } | ||
2974 | } | ||
2975 | |||
2976 | // resort the list if needed | ||
2977 | for(;;) { | ||
2978 | int changed=0; | ||
2979 | step = &active; | ||
2980 | while (*step && (*step)->next) { | ||
2981 | if ((*step)->x > (*step)->next->x) { | ||
2982 | stbtt__active_edge *t = *step; | ||
2983 | stbtt__active_edge *q = t->next; | ||
2984 | |||
2985 | t->next = q->next; | ||
2986 | q->next = t; | ||
2987 | *step = q; | ||
2988 | changed = 1; | ||
2989 | } | ||
2990 | step = &(*step)->next; | ||
2991 | } | ||
2992 | if (!changed) break; | ||
2993 | } | ||
2994 | |||
2995 | // insert all edges that start before the center of this scanline -- omit ones that also end on this scanline | ||
2996 | while (e->y0 <= scan_y) { | ||
2997 | if (e->y1 > scan_y) { | ||
2998 | stbtt__active_edge *z = stbtt__new_active(&hh, e, off_x, scan_y, userdata); | ||
2999 | if (z != NULL) { | ||
3000 | // find insertion point | ||
3001 | if (active == NULL) | ||
3002 | active = z; | ||
3003 | else if (z->x < active->x) { | ||
3004 | // insert at front | ||
3005 | z->next = active; | ||
3006 | active = z; | ||
3007 | } else { | ||
3008 | // find thing to insert AFTER | ||
3009 | stbtt__active_edge *p = active; | ||
3010 | while (p->next && p->next->x < z->x) | ||
3011 | p = p->next; | ||
3012 | // at this point, p->next->x is NOT < z->x | ||
3013 | z->next = p->next; | ||
3014 | p->next = z; | ||
3015 | } | ||
3016 | } | ||
3017 | } | ||
3018 | ++e; | ||
3019 | } | ||
3020 | |||
3021 | // now process all active edges in XOR fashion | ||
3022 | if (active) | ||
3023 | stbtt__fill_active_edges(scanline, result->w, active, max_weight); | ||
3024 | |||
3025 | ++y; | ||
3026 | } | ||
3027 | STBTT_memcpy(result->pixels + j * result->stride, scanline, result->w); | ||
3028 | ++j; | ||
3029 | } | ||
3030 | |||
3031 | stbtt__hheap_cleanup(&hh, userdata); | ||
3032 | |||
3033 | if (scanline != scanline_data) | ||
3034 | STBTT_free(scanline, userdata); | ||
3035 | } | ||
3036 | |||
3037 | #elif STBTT_RASTERIZER_VERSION == 2 | ||
3038 | |||
3039 | // the edge passed in here does not cross the vertical line at x or the vertical line at x+1 | ||
3040 | // (i.e. it has already been clipped to those) | ||
3041 | static void stbtt__handle_clipped_edge(float *scanline, int x, stbtt__active_edge *e, float x0, float y0, float x1, float y1) | ||
3042 | { | ||
3043 | if (y0 == y1) return; | ||
3044 | STBTT_assert(y0 < y1); | ||
3045 | STBTT_assert(e->sy <= e->ey); | ||
3046 | if (y0 > e->ey) return; | ||
3047 | if (y1 < e->sy) return; | ||
3048 | if (y0 < e->sy) { | ||
3049 | x0 += (x1-x0) * (e->sy - y0) / (y1-y0); | ||
3050 | y0 = e->sy; | ||
3051 | } | ||
3052 | if (y1 > e->ey) { | ||
3053 | x1 += (x1-x0) * (e->ey - y1) / (y1-y0); | ||
3054 | y1 = e->ey; | ||
3055 | } | ||
3056 | |||
3057 | if (x0 == x) | ||
3058 | STBTT_assert(x1 <= x+1); | ||
3059 | else if (x0 == x+1) | ||
3060 | STBTT_assert(x1 >= x); | ||
3061 | else if (x0 <= x) | ||
3062 | STBTT_assert(x1 <= x); | ||
3063 | else if (x0 >= x+1) | ||
3064 | STBTT_assert(x1 >= x+1); | ||
3065 | else | ||
3066 | STBTT_assert(x1 >= x && x1 <= x+1); | ||
3067 | |||
3068 | if (x0 <= x && x1 <= x) | ||
3069 | scanline[x] += e->direction * (y1-y0); | ||
3070 | else if (x0 >= x+1 && x1 >= x+1) | ||
3071 | ; | ||
3072 | else { | ||
3073 | STBTT_assert(x0 >= x && x0 <= x+1 && x1 >= x && x1 <= x+1); | ||
3074 | scanline[x] += e->direction * (y1-y0) * (1-((x0-x)+(x1-x))/2); // coverage = 1 - average x position | ||
3075 | } | ||
3076 | } | ||
3077 | |||
3078 | static void stbtt__fill_active_edges_new(float *scanline, float *scanline_fill, int len, stbtt__active_edge *e, float y_top) | ||
3079 | { | ||
3080 | float y_bottom = y_top+1; | ||
3081 | |||
3082 | while (e) { | ||
3083 | // brute force every pixel | ||
3084 | |||
3085 | // compute intersection points with top & bottom | ||
3086 | STBTT_assert(e->ey >= y_top); | ||
3087 | |||
3088 | if (e->fdx == 0) { | ||
3089 | float x0 = e->fx; | ||
3090 | if (x0 < len) { | ||
3091 | if (x0 >= 0) { | ||
3092 | stbtt__handle_clipped_edge(scanline,(int) x0,e, x0,y_top, x0,y_bottom); | ||
3093 | stbtt__handle_clipped_edge(scanline_fill-1,(int) x0+1,e, x0,y_top, x0,y_bottom); | ||
3094 | } else { | ||
3095 | stbtt__handle_clipped_edge(scanline_fill-1,0,e, x0,y_top, x0,y_bottom); | ||
3096 | } | ||
3097 | } | ||
3098 | } else { | ||
3099 | float x0 = e->fx; | ||
3100 | float dx = e->fdx; | ||
3101 | float xb = x0 + dx; | ||
3102 | float x_top, x_bottom; | ||
3103 | float sy0,sy1; | ||
3104 | float dy = e->fdy; | ||
3105 | STBTT_assert(e->sy <= y_bottom && e->ey >= y_top); | ||
3106 | |||
3107 | // compute endpoints of line segment clipped to this scanline (if the | ||
3108 | // line segment starts on this scanline. x0 is the intersection of the | ||
3109 | // line with y_top, but that may be off the line segment. | ||
3110 | if (e->sy > y_top) { | ||
3111 | x_top = x0 + dx * (e->sy - y_top); | ||
3112 | sy0 = e->sy; | ||
3113 | } else { | ||
3114 | x_top = x0; | ||
3115 | sy0 = y_top; | ||
3116 | } | ||
3117 | if (e->ey < y_bottom) { | ||
3118 | x_bottom = x0 + dx * (e->ey - y_top); | ||
3119 | sy1 = e->ey; | ||
3120 | } else { | ||
3121 | x_bottom = xb; | ||
3122 | sy1 = y_bottom; | ||
3123 | } | ||
3124 | |||
3125 | if (x_top >= 0 && x_bottom >= 0 && x_top < len && x_bottom < len) { | ||
3126 | // from here on, we don't have to range check x values | ||
3127 | |||
3128 | if ((int) x_top == (int) x_bottom) { | ||
3129 | float height; | ||
3130 | // simple case, only spans one pixel | ||
3131 | int x = (int) x_top; | ||
3132 | height = sy1 - sy0; | ||
3133 | STBTT_assert(x >= 0 && x < len); | ||
3134 | scanline[x] += e->direction * (1-((x_top - x) + (x_bottom-x))/2) * height; | ||
3135 | scanline_fill[x] += e->direction * height; // everything right of this pixel is filled | ||
3136 | } else { | ||
3137 | int x,x1,x2; | ||
3138 | float y_crossing, step, sign, area; | ||
3139 | // covers 2+ pixels | ||
3140 | if (x_top > x_bottom) { | ||
3141 | // flip scanline vertically; signed area is the same | ||
3142 | float t; | ||
3143 | sy0 = y_bottom - (sy0 - y_top); | ||
3144 | sy1 = y_bottom - (sy1 - y_top); | ||
3145 | t = sy0, sy0 = sy1, sy1 = t; | ||
3146 | t = x_bottom, x_bottom = x_top, x_top = t; | ||
3147 | dx = -dx; | ||
3148 | dy = -dy; | ||
3149 | t = x0, x0 = xb, xb = t; | ||
3150 | } | ||
3151 | |||
3152 | x1 = (int) x_top; | ||
3153 | x2 = (int) x_bottom; | ||
3154 | // compute intersection with y axis at x1+1 | ||
3155 | y_crossing = (x1+1 - x0) * dy + y_top; | ||
3156 | |||
3157 | sign = e->direction; | ||
3158 | // area of the rectangle covered from y0..y_crossing | ||
3159 | area = sign * (y_crossing-sy0); | ||
3160 | // area of the triangle (x_top,y0), (x+1,y0), (x+1,y_crossing) | ||
3161 | scanline[x1] += area * (1-((x_top - x1)+(x1+1-x1))/2); | ||
3162 | |||
3163 | step = sign * dy; | ||
3164 | for (x = x1+1; x < x2; ++x) { | ||
3165 | scanline[x] += area + step/2; | ||
3166 | area += step; | ||
3167 | } | ||
3168 | y_crossing += dy * (x2 - (x1+1)); | ||
3169 | |||
3170 | STBTT_assert(STBTT_fabs(area) <= 1.01f); | ||
3171 | |||
3172 | scanline[x2] += area + sign * (1-((x2-x2)+(x_bottom-x2))/2) * (sy1-y_crossing); | ||
3173 | |||
3174 | scanline_fill[x2] += sign * (sy1-sy0); | ||
3175 | } | ||
3176 | } else { | ||
3177 | // if edge goes outside of box we're drawing, we require | ||
3178 | // clipping logic. since this does not match the intended use | ||
3179 | // of this library, we use a different, very slow brute | ||
3180 | // force implementation | ||
3181 | int x; | ||
3182 | for (x=0; x < len; ++x) { | ||
3183 | // cases: | ||
3184 | // | ||
3185 | // there can be up to two intersections with the pixel. any intersection | ||
3186 | // with left or right edges can be handled by splitting into two (or three) | ||
3187 | // regions. intersections with top & bottom do not necessitate case-wise logic. | ||
3188 | // | ||
3189 | // the old way of doing this found the intersections with the left & right edges, | ||
3190 | // then used some simple logic to produce up to three segments in sorted order | ||
3191 | // from top-to-bottom. however, this had a problem: if an x edge was epsilon | ||
3192 | // across the x border, then the corresponding y position might not be distinct | ||
3193 | // from the other y segment, and it might ignored as an empty segment. to avoid | ||
3194 | // that, we need to explicitly produce segments based on x positions. | ||
3195 | |||
3196 | // rename variables to clearly-defined pairs | ||
3197 | float y0 = y_top; | ||
3198 | float x1 = (float) (x); | ||
3199 | float x2 = (float) (x+1); | ||
3200 | float x3 = xb; | ||
3201 | float y3 = y_bottom; | ||
3202 | |||
3203 | // x = e->x + e->dx * (y-y_top) | ||
3204 | // (y-y_top) = (x - e->x) / e->dx | ||
3205 | // y = (x - e->x) / e->dx + y_top | ||
3206 | float y1 = (x - x0) / dx + y_top; | ||
3207 | float y2 = (x+1 - x0) / dx + y_top; | ||
3208 | |||
3209 | if (x0 < x1 && x3 > x2) { // three segments descending down-right | ||
3210 | stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x1,y1); | ||
3211 | stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x2,y2); | ||
3212 | stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x3,y3); | ||
3213 | } else if (x3 < x1 && x0 > x2) { // three segments descending down-left | ||
3214 | stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x2,y2); | ||
3215 | stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x1,y1); | ||
3216 | stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x3,y3); | ||
3217 | } else if (x0 < x1 && x3 > x1) { // two segments across x, down-right | ||
3218 | stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x1,y1); | ||
3219 | stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x3,y3); | ||
3220 | } else if (x3 < x1 && x0 > x1) { // two segments across x, down-left | ||
3221 | stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x1,y1); | ||
3222 | stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x3,y3); | ||
3223 | } else if (x0 < x2 && x3 > x2) { // two segments across x+1, down-right | ||
3224 | stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x2,y2); | ||
3225 | stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x3,y3); | ||
3226 | } else if (x3 < x2 && x0 > x2) { // two segments across x+1, down-left | ||
3227 | stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x2,y2); | ||
3228 | stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x3,y3); | ||
3229 | } else { // one segment | ||
3230 | stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x3,y3); | ||
3231 | } | ||
3232 | } | ||
3233 | } | ||
3234 | } | ||
3235 | e = e->next; | ||
3236 | } | ||
3237 | } | ||
3238 | |||
3239 | // directly AA rasterize edges w/o supersampling | ||
3240 | static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e, int n, int vsubsample, int off_x, int off_y, void *userdata) | ||
3241 | { | ||
3242 | stbtt__hheap hh = { 0, 0, 0 }; | ||
3243 | stbtt__active_edge *active = NULL; | ||
3244 | int y,j=0, i; | ||
3245 | float scanline_data[129], *scanline, *scanline2; | ||
3246 | |||
3247 | STBTT__NOTUSED(vsubsample); | ||
3248 | |||
3249 | if (result->w > 64) | ||
3250 | scanline = (float *) STBTT_malloc((result->w*2+1) * sizeof(float), userdata); | ||
3251 | else | ||
3252 | scanline = scanline_data; | ||
3253 | |||
3254 | scanline2 = scanline + result->w; | ||
3255 | |||
3256 | y = off_y; | ||
3257 | e[n].y0 = (float) (off_y + result->h) + 1; | ||
3258 | |||
3259 | while (j < result->h) { | ||
3260 | // find center of pixel for this scanline | ||
3261 | float scan_y_top = y + 0.0f; | ||
3262 | float scan_y_bottom = y + 1.0f; | ||
3263 | stbtt__active_edge **step = &active; | ||
3264 | |||
3265 | STBTT_memset(scanline , 0, result->w*sizeof(scanline[0])); | ||
3266 | STBTT_memset(scanline2, 0, (result->w+1)*sizeof(scanline[0])); | ||
3267 | |||
3268 | // update all active edges; | ||
3269 | // remove all active edges that terminate before the top of this scanline | ||
3270 | while (*step) { | ||
3271 | stbtt__active_edge * z = *step; | ||
3272 | if (z->ey <= scan_y_top) { | ||
3273 | *step = z->next; // delete from list | ||
3274 | STBTT_assert(z->direction); | ||
3275 | z->direction = 0; | ||
3276 | stbtt__hheap_free(&hh, z); | ||
3277 | } else { | ||
3278 | step = &((*step)->next); // advance through list | ||
3279 | } | ||
3280 | } | ||
3281 | |||
3282 | // insert all edges that start before the bottom of this scanline | ||
3283 | while (e->y0 <= scan_y_bottom) { | ||
3284 | if (e->y0 != e->y1) { | ||
3285 | stbtt__active_edge *z = stbtt__new_active(&hh, e, off_x, scan_y_top, userdata); | ||
3286 | if (z != NULL) { | ||
3287 | if (j == 0 && off_y != 0) { | ||
3288 | if (z->ey < scan_y_top) { | ||
3289 | // this can happen due to subpixel positioning and some kind of fp rounding error i think | ||
3290 | z->ey = scan_y_top; | ||
3291 | } | ||
3292 | } | ||
3293 | STBTT_assert(z->ey >= scan_y_top); // if we get really unlucky a tiny bit of an edge can be out of bounds | ||
3294 | // insert at front | ||
3295 | z->next = active; | ||
3296 | active = z; | ||
3297 | } | ||
3298 | } | ||
3299 | ++e; | ||
3300 | } | ||
3301 | |||
3302 | // now process all active edges | ||
3303 | if (active) | ||
3304 | stbtt__fill_active_edges_new(scanline, scanline2+1, result->w, active, scan_y_top); | ||
3305 | |||
3306 | { | ||
3307 | float sum = 0; | ||
3308 | for (i=0; i < result->w; ++i) { | ||
3309 | float k; | ||
3310 | int m; | ||
3311 | sum += scanline2[i]; | ||
3312 | k = scanline[i] + sum; | ||
3313 | k = (float) STBTT_fabs(k)*255 + 0.5f; | ||
3314 | m = (int) k; | ||
3315 | if (m > 255) m = 255; | ||
3316 | result->pixels[j*result->stride + i] = (unsigned char) m; | ||
3317 | } | ||
3318 | } | ||
3319 | // advance all the edges | ||
3320 | step = &active; | ||
3321 | while (*step) { | ||
3322 | stbtt__active_edge *z = *step; | ||
3323 | z->fx += z->fdx; // advance to position for current scanline | ||
3324 | step = &((*step)->next); // advance through list | ||
3325 | } | ||
3326 | |||
3327 | ++y; | ||
3328 | ++j; | ||
3329 | } | ||
3330 | |||
3331 | stbtt__hheap_cleanup(&hh, userdata); | ||
3332 | |||
3333 | if (scanline != scanline_data) | ||
3334 | STBTT_free(scanline, userdata); | ||
3335 | } | ||
3336 | #else | ||
3337 | #error "Unrecognized value of STBTT_RASTERIZER_VERSION" | ||
3338 | #endif | ||
3339 | |||
3340 | #define STBTT__COMPARE(a,b) ((a)->y0 < (b)->y0) | ||
3341 | |||
3342 | static void stbtt__sort_edges_ins_sort(stbtt__edge *p, int n) | ||
3343 | { | ||
3344 | int i,j; | ||
3345 | for (i=1; i < n; ++i) { | ||
3346 | stbtt__edge t = p[i], *a = &t; | ||
3347 | j = i; | ||
3348 | while (j > 0) { | ||
3349 | stbtt__edge *b = &p[j-1]; | ||
3350 | int c = STBTT__COMPARE(a,b); | ||
3351 | if (!c) break; | ||
3352 | p[j] = p[j-1]; | ||
3353 | --j; | ||
3354 | } | ||
3355 | if (i != j) | ||
3356 | p[j] = t; | ||
3357 | } | ||
3358 | } | ||
3359 | |||
3360 | static void stbtt__sort_edges_quicksort(stbtt__edge *p, int n) | ||
3361 | { | ||
3362 | /* threshold for transitioning to insertion sort */ | ||
3363 | while (n > 12) { | ||
3364 | stbtt__edge t; | ||
3365 | int c01,c12,c,m,i,j; | ||
3366 | |||
3367 | /* compute median of three */ | ||
3368 | m = n >> 1; | ||
3369 | c01 = STBTT__COMPARE(&p[0],&p[m]); | ||
3370 | c12 = STBTT__COMPARE(&p[m],&p[n-1]); | ||
3371 | /* if 0 >= mid >= end, or 0 < mid < end, then use mid */ | ||
3372 | if (c01 != c12) { | ||
3373 | /* otherwise, we'll need to swap something else to middle */ | ||
3374 | int z; | ||
3375 | c = STBTT__COMPARE(&p[0],&p[n-1]); | ||
3376 | /* 0>mid && mid<n: 0>n => n; 0<n => 0 */ | ||
3377 | /* 0<mid && mid>n: 0>n => 0; 0<n => n */ | ||
3378 | z = (c == c12) ? 0 : n-1; | ||
3379 | t = p[z]; | ||
3380 | p[z] = p[m]; | ||
3381 | p[m] = t; | ||
3382 | } | ||
3383 | /* now p[m] is the median-of-three */ | ||
3384 | /* swap it to the beginning so it won't move around */ | ||
3385 | t = p[0]; | ||
3386 | p[0] = p[m]; | ||
3387 | p[m] = t; | ||
3388 | |||
3389 | /* partition loop */ | ||
3390 | i=1; | ||
3391 | j=n-1; | ||
3392 | for(;;) { | ||
3393 | /* handling of equality is crucial here */ | ||
3394 | /* for sentinels & efficiency with duplicates */ | ||
3395 | for (;;++i) { | ||
3396 | if (!STBTT__COMPARE(&p[i], &p[0])) break; | ||
3397 | } | ||
3398 | for (;;--j) { | ||
3399 | if (!STBTT__COMPARE(&p[0], &p[j])) break; | ||
3400 | } | ||
3401 | /* make sure we haven't crossed */ | ||
3402 | if (i >= j) break; | ||
3403 | t = p[i]; | ||
3404 | p[i] = p[j]; | ||
3405 | p[j] = t; | ||
3406 | |||
3407 | ++i; | ||
3408 | --j; | ||
3409 | } | ||
3410 | /* recurse on smaller side, iterate on larger */ | ||
3411 | if (j < (n-i)) { | ||
3412 | stbtt__sort_edges_quicksort(p,j); | ||
3413 | p = p+i; | ||
3414 | n = n-i; | ||
3415 | } else { | ||
3416 | stbtt__sort_edges_quicksort(p+i, n-i); | ||
3417 | n = j; | ||
3418 | } | ||
3419 | } | ||
3420 | } | ||
3421 | |||
3422 | static void stbtt__sort_edges(stbtt__edge *p, int n) | ||
3423 | { | ||
3424 | stbtt__sort_edges_quicksort(p, n); | ||
3425 | stbtt__sort_edges_ins_sort(p, n); | ||
3426 | } | ||
3427 | |||
3428 | typedef struct | ||
3429 | { | ||
3430 | float x,y; | ||
3431 | } stbtt__point; | ||
3432 | |||
3433 | static void stbtt__rasterize(stbtt__bitmap *result, stbtt__point *pts, int *wcount, int windings, float scale_x, float scale_y, float shift_x, float shift_y, int off_x, int off_y, int invert, void *userdata) | ||
3434 | { | ||
3435 | float y_scale_inv = invert ? -scale_y : scale_y; | ||
3436 | stbtt__edge *e; | ||
3437 | int n,i,j,k,m; | ||
3438 | #if STBTT_RASTERIZER_VERSION == 1 | ||
3439 | int vsubsample = result->h < 8 ? 15 : 5; | ||
3440 | #elif STBTT_RASTERIZER_VERSION == 2 | ||
3441 | int vsubsample = 1; | ||
3442 | #else | ||
3443 | #error "Unrecognized value of STBTT_RASTERIZER_VERSION" | ||
3444 | #endif | ||
3445 | // vsubsample should divide 255 evenly; otherwise we won't reach full opacity | ||
3446 | |||
3447 | // now we have to blow out the windings into explicit edge lists | ||
3448 | n = 0; | ||
3449 | for (i=0; i < windings; ++i) | ||
3450 | n += wcount[i]; | ||
3451 | |||
3452 | e = (stbtt__edge *) STBTT_malloc(sizeof(*e) * (n+1), userdata); // add an extra one as a sentinel | ||
3453 | if (e == 0) return; | ||
3454 | n = 0; | ||
3455 | |||
3456 | m=0; | ||
3457 | for (i=0; i < windings; ++i) { | ||
3458 | stbtt__point *p = pts + m; | ||
3459 | m += wcount[i]; | ||
3460 | j = wcount[i]-1; | ||
3461 | for (k=0; k < wcount[i]; j=k++) { | ||
3462 | int a=k,b=j; | ||
3463 | // skip the edge if horizontal | ||
3464 | if (p[j].y == p[k].y) | ||
3465 | continue; | ||
3466 | // add edge from j to k to the list | ||
3467 | e[n].invert = 0; | ||
3468 | if (invert ? p[j].y > p[k].y : p[j].y < p[k].y) { | ||
3469 | e[n].invert = 1; | ||
3470 | a=j,b=k; | ||
3471 | } | ||
3472 | e[n].x0 = p[a].x * scale_x + shift_x; | ||
3473 | e[n].y0 = (p[a].y * y_scale_inv + shift_y) * vsubsample; | ||
3474 | e[n].x1 = p[b].x * scale_x + shift_x; | ||
3475 | e[n].y1 = (p[b].y * y_scale_inv + shift_y) * vsubsample; | ||
3476 | ++n; | ||
3477 | } | ||
3478 | } | ||
3479 | |||
3480 | // now sort the edges by their highest point (should snap to integer, and then by x) | ||
3481 | //STBTT_sort(e, n, sizeof(e[0]), stbtt__edge_compare); | ||
3482 | stbtt__sort_edges(e, n); | ||
3483 | |||
3484 | // now, traverse the scanlines and find the intersections on each scanline, use xor winding rule | ||
3485 | stbtt__rasterize_sorted_edges(result, e, n, vsubsample, off_x, off_y, userdata); | ||
3486 | |||
3487 | STBTT_free(e, userdata); | ||
3488 | } | ||
3489 | |||
3490 | static void stbtt__add_point(stbtt__point *points, int n, float x, float y) | ||
3491 | { | ||
3492 | if (!points) return; // during first pass, it's unallocated | ||
3493 | points[n].x = x; | ||
3494 | points[n].y = y; | ||
3495 | } | ||
3496 | |||
3497 | // tessellate until threshold p is happy... @TODO warped to compensate for non-linear stretching | ||
3498 | static int stbtt__tesselate_curve(stbtt__point *points, int *num_points, float x0, float y0, float x1, float y1, float x2, float y2, float objspace_flatness_squared, int n) | ||
3499 | { | ||
3500 | // midpoint | ||
3501 | float mx = (x0 + 2*x1 + x2)/4; | ||
3502 | float my = (y0 + 2*y1 + y2)/4; | ||
3503 | // versus directly drawn line | ||
3504 | float dx = (x0+x2)/2 - mx; | ||
3505 | float dy = (y0+y2)/2 - my; | ||
3506 | if (n > 16) // 65536 segments on one curve better be enough! | ||
3507 | return 1; | ||
3508 | if (dx*dx+dy*dy > objspace_flatness_squared) { // half-pixel error allowed... need to be smaller if AA | ||
3509 | stbtt__tesselate_curve(points, num_points, x0,y0, (x0+x1)/2.0f,(y0+y1)/2.0f, mx,my, objspace_flatness_squared,n+1); | ||
3510 | stbtt__tesselate_curve(points, num_points, mx,my, (x1+x2)/2.0f,(y1+y2)/2.0f, x2,y2, objspace_flatness_squared,n+1); | ||
3511 | } else { | ||
3512 | stbtt__add_point(points, *num_points,x2,y2); | ||
3513 | *num_points = *num_points+1; | ||
3514 | } | ||
3515 | return 1; | ||
3516 | } | ||
3517 | |||
3518 | static void stbtt__tesselate_cubic(stbtt__point *points, int *num_points, float x0, float y0, float x1, float y1, float x2, float y2, float x3, float y3, float objspace_flatness_squared, int n) | ||
3519 | { | ||
3520 | // @TODO this "flatness" calculation is just made-up nonsense that seems to work well enough | ||
3521 | float dx0 = x1-x0; | ||
3522 | float dy0 = y1-y0; | ||
3523 | float dx1 = x2-x1; | ||
3524 | float dy1 = y2-y1; | ||
3525 | float dx2 = x3-x2; | ||
3526 | float dy2 = y3-y2; | ||
3527 | float dx = x3-x0; | ||
3528 | float dy = y3-y0; | ||
3529 | float longlen = (float) (STBTT_sqrt(dx0*dx0+dy0*dy0)+STBTT_sqrt(dx1*dx1+dy1*dy1)+STBTT_sqrt(dx2*dx2+dy2*dy2)); | ||
3530 | float shortlen = (float) STBTT_sqrt(dx*dx+dy*dy); | ||
3531 | float flatness_squared = longlen*longlen-shortlen*shortlen; | ||
3532 | |||
3533 | if (n > 16) // 65536 segments on one curve better be enough! | ||
3534 | return; | ||
3535 | |||
3536 | if (flatness_squared > objspace_flatness_squared) { | ||
3537 | float x01 = (x0+x1)/2; | ||
3538 | float y01 = (y0+y1)/2; | ||
3539 | float x12 = (x1+x2)/2; | ||
3540 | float y12 = (y1+y2)/2; | ||
3541 | float x23 = (x2+x3)/2; | ||
3542 | float y23 = (y2+y3)/2; | ||
3543 | |||
3544 | float xa = (x01+x12)/2; | ||
3545 | float ya = (y01+y12)/2; | ||
3546 | float xb = (x12+x23)/2; | ||
3547 | float yb = (y12+y23)/2; | ||
3548 | |||
3549 | float mx = (xa+xb)/2; | ||
3550 | float my = (ya+yb)/2; | ||
3551 | |||
3552 | stbtt__tesselate_cubic(points, num_points, x0,y0, x01,y01, xa,ya, mx,my, objspace_flatness_squared,n+1); | ||
3553 | stbtt__tesselate_cubic(points, num_points, mx,my, xb,yb, x23,y23, x3,y3, objspace_flatness_squared,n+1); | ||
3554 | } else { | ||
3555 | stbtt__add_point(points, *num_points,x3,y3); | ||
3556 | *num_points = *num_points+1; | ||
3557 | } | ||
3558 | } | ||
3559 | |||
3560 | // returns number of contours | ||
3561 | static stbtt__point *stbtt_FlattenCurves(stbtt_vertex *vertices, int num_verts, float objspace_flatness, int **contour_lengths, int *num_contours, void *userdata) | ||
3562 | { | ||
3563 | stbtt__point *points=0; | ||
3564 | int num_points=0; | ||
3565 | |||
3566 | float objspace_flatness_squared = objspace_flatness * objspace_flatness; | ||
3567 | int i,n=0,start=0, pass; | ||
3568 | |||
3569 | // count how many "moves" there are to get the contour count | ||
3570 | for (i=0; i < num_verts; ++i) | ||
3571 | if (vertices[i].type == STBTT_vmove) | ||
3572 | ++n; | ||
3573 | |||
3574 | *num_contours = n; | ||
3575 | if (n == 0) return 0; | ||
3576 | |||
3577 | *contour_lengths = (int *) STBTT_malloc(sizeof(**contour_lengths) * n, userdata); | ||
3578 | |||
3579 | if (*contour_lengths == 0) { | ||
3580 | *num_contours = 0; | ||
3581 | return 0; | ||
3582 | } | ||
3583 | |||
3584 | // make two passes through the points so we don't need to realloc | ||
3585 | for (pass=0; pass < 2; ++pass) { | ||
3586 | float x=0,y=0; | ||
3587 | if (pass == 1) { | ||
3588 | points = (stbtt__point *) STBTT_malloc(num_points * sizeof(points[0]), userdata); | ||
3589 | if (points == NULL) goto error; | ||
3590 | } | ||
3591 | num_points = 0; | ||
3592 | n= -1; | ||
3593 | for (i=0; i < num_verts; ++i) { | ||
3594 | switch (vertices[i].type) { | ||
3595 | case STBTT_vmove: | ||
3596 | // start the next contour | ||
3597 | if (n >= 0) | ||
3598 | (*contour_lengths)[n] = num_points - start; | ||
3599 | ++n; | ||
3600 | start = num_points; | ||
3601 | |||
3602 | x = vertices[i].x, y = vertices[i].y; | ||
3603 | stbtt__add_point(points, num_points++, x,y); | ||
3604 | break; | ||
3605 | case STBTT_vline: | ||
3606 | x = vertices[i].x, y = vertices[i].y; | ||
3607 | stbtt__add_point(points, num_points++, x, y); | ||
3608 | break; | ||
3609 | case STBTT_vcurve: | ||
3610 | stbtt__tesselate_curve(points, &num_points, x,y, | ||
3611 | vertices[i].cx, vertices[i].cy, | ||
3612 | vertices[i].x, vertices[i].y, | ||
3613 | objspace_flatness_squared, 0); | ||
3614 | x = vertices[i].x, y = vertices[i].y; | ||
3615 | break; | ||
3616 | case STBTT_vcubic: | ||
3617 | stbtt__tesselate_cubic(points, &num_points, x,y, | ||
3618 | vertices[i].cx, vertices[i].cy, | ||
3619 | vertices[i].cx1, vertices[i].cy1, | ||
3620 | vertices[i].x, vertices[i].y, | ||
3621 | objspace_flatness_squared, 0); | ||
3622 | x = vertices[i].x, y = vertices[i].y; | ||
3623 | break; | ||
3624 | } | ||
3625 | } | ||
3626 | (*contour_lengths)[n] = num_points - start; | ||
3627 | } | ||
3628 | |||
3629 | return points; | ||
3630 | error: | ||
3631 | STBTT_free(points, userdata); | ||
3632 | STBTT_free(*contour_lengths, userdata); | ||
3633 | *contour_lengths = 0; | ||
3634 | *num_contours = 0; | ||
3635 | return NULL; | ||
3636 | } | ||
3637 | |||
3638 | STBTT_DEF void stbtt_Rasterize(stbtt__bitmap *result, float flatness_in_pixels, stbtt_vertex *vertices, int num_verts, float scale_x, float scale_y, float shift_x, float shift_y, int x_off, int y_off, int invert, void *userdata) | ||
3639 | { | ||
3640 | float scale = scale_x > scale_y ? scale_y : scale_x; | ||
3641 | int winding_count = 0; | ||
3642 | int *winding_lengths = NULL; | ||
3643 | stbtt__point *windings = stbtt_FlattenCurves(vertices, num_verts, flatness_in_pixels / scale, &winding_lengths, &winding_count, userdata); | ||
3644 | if (windings) { | ||
3645 | stbtt__rasterize(result, windings, winding_lengths, winding_count, scale_x, scale_y, shift_x, shift_y, x_off, y_off, invert, userdata); | ||
3646 | STBTT_free(winding_lengths, userdata); | ||
3647 | STBTT_free(windings, userdata); | ||
3648 | } | ||
3649 | } | ||
3650 | |||
3651 | STBTT_DEF void stbtt_FreeBitmap(unsigned char *bitmap, void *userdata) | ||
3652 | { | ||
3653 | STBTT_free(bitmap, userdata); | ||
3654 | } | ||
3655 | |||
3656 | STBTT_DEF unsigned char *stbtt_GetGlyphBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int glyph, int *width, int *height, int *xoff, int *yoff) | ||
3657 | { | ||
3658 | int ix0,iy0,ix1,iy1; | ||
3659 | stbtt__bitmap gbm; | ||
3660 | stbtt_vertex *vertices; | ||
3661 | int num_verts = stbtt_GetGlyphShape(info, glyph, &vertices); | ||
3662 | |||
3663 | if (scale_x == 0) scale_x = scale_y; | ||
3664 | if (scale_y == 0) { | ||
3665 | if (scale_x == 0) { | ||
3666 | STBTT_free(vertices, info->userdata); | ||
3667 | return NULL; | ||
3668 | } | ||
3669 | scale_y = scale_x; | ||
3670 | } | ||
3671 | |||
3672 | stbtt_GetGlyphBitmapBoxSubpixel(info, glyph, scale_x, scale_y, shift_x, shift_y, &ix0,&iy0,&ix1,&iy1); | ||
3673 | |||
3674 | // now we get the size | ||
3675 | gbm.w = (ix1 - ix0); | ||
3676 | gbm.h = (iy1 - iy0); | ||
3677 | gbm.pixels = NULL; // in case we error | ||
3678 | |||
3679 | if (width ) *width = gbm.w; | ||
3680 | if (height) *height = gbm.h; | ||
3681 | if (xoff ) *xoff = ix0; | ||
3682 | if (yoff ) *yoff = iy0; | ||
3683 | |||
3684 | if (gbm.w && gbm.h) { | ||
3685 | gbm.pixels = (unsigned char *) STBTT_malloc(gbm.w * gbm.h, info->userdata); | ||
3686 | if (gbm.pixels) { | ||
3687 | gbm.stride = gbm.w; | ||
3688 | |||
3689 | stbtt_Rasterize(&gbm, 0.35f, vertices, num_verts, scale_x, scale_y, shift_x, shift_y, ix0, iy0, 1, info->userdata); | ||
3690 | } | ||
3691 | } | ||
3692 | STBTT_free(vertices, info->userdata); | ||
3693 | return gbm.pixels; | ||
3694 | } | ||
3695 | |||
3696 | STBTT_DEF unsigned char *stbtt_GetGlyphBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int glyph, int *width, int *height, int *xoff, int *yoff) | ||
3697 | { | ||
3698 | return stbtt_GetGlyphBitmapSubpixel(info, scale_x, scale_y, 0.0f, 0.0f, glyph, width, height, xoff, yoff); | ||
3699 | } | ||
3700 | |||
3701 | STBTT_DEF void stbtt_MakeGlyphBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int glyph) | ||
3702 | { | ||
3703 | int ix0,iy0; | ||
3704 | stbtt_vertex *vertices; | ||
3705 | int num_verts = stbtt_GetGlyphShape(info, glyph, &vertices); | ||
3706 | stbtt__bitmap gbm; | ||
3707 | |||
3708 | stbtt_GetGlyphBitmapBoxSubpixel(info, glyph, scale_x, scale_y, shift_x, shift_y, &ix0,&iy0,0,0); | ||
3709 | gbm.pixels = output; | ||
3710 | gbm.w = out_w; | ||
3711 | gbm.h = out_h; | ||
3712 | gbm.stride = out_stride; | ||
3713 | |||
3714 | if (gbm.w && gbm.h) | ||
3715 | stbtt_Rasterize(&gbm, 0.35f, vertices, num_verts, scale_x, scale_y, shift_x, shift_y, ix0,iy0, 1, info->userdata); | ||
3716 | |||
3717 | STBTT_free(vertices, info->userdata); | ||
3718 | } | ||
3719 | |||
3720 | STBTT_DEF void stbtt_MakeGlyphBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int glyph) | ||
3721 | { | ||
3722 | stbtt_MakeGlyphBitmapSubpixel(info, output, out_w, out_h, out_stride, scale_x, scale_y, 0.0f,0.0f, glyph); | ||
3723 | } | ||
3724 | |||
3725 | STBTT_DEF unsigned char *stbtt_GetCodepointBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint, int *width, int *height, int *xoff, int *yoff) | ||
3726 | { | ||
3727 | return stbtt_GetGlyphBitmapSubpixel(info, scale_x, scale_y,shift_x,shift_y, stbtt_FindGlyphIndex(info,codepoint), width,height,xoff,yoff); | ||
3728 | } | ||
3729 | |||
3730 | STBTT_DEF void stbtt_MakeCodepointBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int oversample_x, int oversample_y, float *sub_x, float *sub_y, int codepoint) | ||
3731 | { | ||
3732 | stbtt_MakeGlyphBitmapSubpixelPrefilter(info, output, out_w, out_h, out_stride, scale_x, scale_y, shift_x, shift_y, oversample_x, oversample_y, sub_x, sub_y, stbtt_FindGlyphIndex(info,codepoint)); | ||
3733 | } | ||
3734 | |||
3735 | STBTT_DEF void stbtt_MakeCodepointBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint) | ||
3736 | { | ||
3737 | stbtt_MakeGlyphBitmapSubpixel(info, output, out_w, out_h, out_stride, scale_x, scale_y, shift_x, shift_y, stbtt_FindGlyphIndex(info,codepoint)); | ||
3738 | } | ||
3739 | |||
3740 | STBTT_DEF unsigned char *stbtt_GetCodepointBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int codepoint, int *width, int *height, int *xoff, int *yoff) | ||
3741 | { | ||
3742 | return stbtt_GetCodepointBitmapSubpixel(info, scale_x, scale_y, 0.0f,0.0f, codepoint, width,height,xoff,yoff); | ||
3743 | } | ||
3744 | |||
3745 | STBTT_DEF void stbtt_MakeCodepointBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int codepoint) | ||
3746 | { | ||
3747 | stbtt_MakeCodepointBitmapSubpixel(info, output, out_w, out_h, out_stride, scale_x, scale_y, 0.0f,0.0f, codepoint); | ||
3748 | } | ||
3749 | |||
3750 | ////////////////////////////////////////////////////////////////////////////// | ||
3751 | // | ||
3752 | // bitmap baking | ||
3753 | // | ||
3754 | // This is SUPER-CRAPPY packing to keep source code small | ||
3755 | |||
3756 | static int stbtt_BakeFontBitmap_internal(unsigned char *data, int offset, // font location (use offset=0 for plain .ttf) | ||
3757 | float pixel_height, // height of font in pixels | ||
3758 | unsigned char *pixels, int pw, int ph, // bitmap to be filled in | ||
3759 | int first_char, int num_chars, // characters to bake | ||
3760 | stbtt_bakedchar *chardata) | ||
3761 | { | ||
3762 | float scale; | ||
3763 | int x,y,bottom_y, i; | ||
3764 | stbtt_fontinfo f; | ||
3765 | f.userdata = NULL; | ||
3766 | if (!stbtt_InitFont(&f, data, offset)) | ||
3767 | return -1; | ||
3768 | STBTT_memset(pixels, 0, pw*ph); // background of 0 around pixels | ||
3769 | x=y=1; | ||
3770 | bottom_y = 1; | ||
3771 | |||
3772 | scale = stbtt_ScaleForPixelHeight(&f, pixel_height); | ||
3773 | |||
3774 | for (i=0; i < num_chars; ++i) { | ||
3775 | int advance, lsb, x0,y0,x1,y1,gw,gh; | ||
3776 | int g = stbtt_FindGlyphIndex(&f, first_char + i); | ||
3777 | stbtt_GetGlyphHMetrics(&f, g, &advance, &lsb); | ||
3778 | stbtt_GetGlyphBitmapBox(&f, g, scale,scale, &x0,&y0,&x1,&y1); | ||
3779 | gw = x1-x0; | ||
3780 | gh = y1-y0; | ||
3781 | if (x + gw + 1 >= pw) | ||
3782 | y = bottom_y, x = 1; // advance to next row | ||
3783 | if (y + gh + 1 >= ph) // check if it fits vertically AFTER potentially moving to next row | ||
3784 | return -i; | ||
3785 | STBTT_assert(x+gw < pw); | ||
3786 | STBTT_assert(y+gh < ph); | ||
3787 | stbtt_MakeGlyphBitmap(&f, pixels+x+y*pw, gw,gh,pw, scale,scale, g); | ||
3788 | chardata[i].x0 = (stbtt_int16) x; | ||
3789 | chardata[i].y0 = (stbtt_int16) y; | ||
3790 | chardata[i].x1 = (stbtt_int16) (x + gw); | ||
3791 | chardata[i].y1 = (stbtt_int16) (y + gh); | ||
3792 | chardata[i].xadvance = scale * advance; | ||
3793 | chardata[i].xoff = (float) x0; | ||
3794 | chardata[i].yoff = (float) y0; | ||
3795 | x = x + gw + 1; | ||
3796 | if (y+gh+1 > bottom_y) | ||
3797 | bottom_y = y+gh+1; | ||
3798 | } | ||
3799 | return bottom_y; | ||
3800 | } | ||
3801 | |||
3802 | STBTT_DEF void stbtt_GetBakedQuad(const stbtt_bakedchar *chardata, int pw, int ph, int char_index, float *xpos, float *ypos, stbtt_aligned_quad *q, int opengl_fillrule) | ||
3803 | { | ||
3804 | float d3d_bias = opengl_fillrule ? 0 : -0.5f; | ||
3805 | float ipw = 1.0f / pw, iph = 1.0f / ph; | ||
3806 | const stbtt_bakedchar *b = chardata + char_index; | ||
3807 | int round_x = STBTT_ifloor((*xpos + b->xoff) + 0.5f); | ||
3808 | int round_y = STBTT_ifloor((*ypos + b->yoff) + 0.5f); | ||
3809 | |||
3810 | q->x0 = round_x + d3d_bias; | ||
3811 | q->y0 = round_y + d3d_bias; | ||
3812 | q->x1 = round_x + b->x1 - b->x0 + d3d_bias; | ||
3813 | q->y1 = round_y + b->y1 - b->y0 + d3d_bias; | ||
3814 | |||
3815 | q->s0 = b->x0 * ipw; | ||
3816 | q->t0 = b->y0 * iph; | ||
3817 | q->s1 = b->x1 * ipw; | ||
3818 | q->t1 = b->y1 * iph; | ||
3819 | |||
3820 | *xpos += b->xadvance; | ||
3821 | } | ||
3822 | |||
3823 | ////////////////////////////////////////////////////////////////////////////// | ||
3824 | // | ||
3825 | // rectangle packing replacement routines if you don't have stb_rect_pack.h | ||
3826 | // | ||
3827 | |||
3828 | #ifndef STB_RECT_PACK_VERSION | ||
3829 | |||
3830 | typedef int stbrp_coord; | ||
3831 | |||
3832 | //////////////////////////////////////////////////////////////////////////////////// | ||
3833 | // // | ||
3834 | // // | ||
3835 | // COMPILER WARNING ?!?!? // | ||
3836 | // // | ||
3837 | // // | ||
3838 | // if you get a compile warning due to these symbols being defined more than // | ||
3839 | // once, move #include "stb_rect_pack.h" before #include "stb_truetype.h" // | ||
3840 | // // | ||
3841 | //////////////////////////////////////////////////////////////////////////////////// | ||
3842 | |||
3843 | typedef struct | ||
3844 | { | ||
3845 | int width,height; | ||
3846 | int x,y,bottom_y; | ||
3847 | } stbrp_context; | ||
3848 | |||
3849 | typedef struct | ||
3850 | { | ||
3851 | unsigned char x; | ||
3852 | } stbrp_node; | ||
3853 | |||
3854 | struct stbrp_rect | ||
3855 | { | ||
3856 | stbrp_coord x,y; | ||
3857 | int id,w,h,was_packed; | ||
3858 | }; | ||
3859 | |||
3860 | static void stbrp_init_target(stbrp_context *con, int pw, int ph, stbrp_node *nodes, int num_nodes) | ||
3861 | { | ||
3862 | con->width = pw; | ||
3863 | con->height = ph; | ||
3864 | con->x = 0; | ||
3865 | con->y = 0; | ||
3866 | con->bottom_y = 0; | ||
3867 | STBTT__NOTUSED(nodes); | ||
3868 | STBTT__NOTUSED(num_nodes); | ||
3869 | } | ||
3870 | |||
3871 | static void stbrp_pack_rects(stbrp_context *con, stbrp_rect *rects, int num_rects) | ||
3872 | { | ||
3873 | int i; | ||
3874 | for (i=0; i < num_rects; ++i) { | ||
3875 | if (con->x + rects[i].w > con->width) { | ||
3876 | con->x = 0; | ||
3877 | con->y = con->bottom_y; | ||
3878 | } | ||
3879 | if (con->y + rects[i].h > con->height) | ||
3880 | break; | ||
3881 | rects[i].x = con->x; | ||
3882 | rects[i].y = con->y; | ||
3883 | rects[i].was_packed = 1; | ||
3884 | con->x += rects[i].w; | ||
3885 | if (con->y + rects[i].h > con->bottom_y) | ||
3886 | con->bottom_y = con->y + rects[i].h; | ||
3887 | } | ||
3888 | for ( ; i < num_rects; ++i) | ||
3889 | rects[i].was_packed = 0; | ||
3890 | } | ||
3891 | #endif | ||
3892 | |||
3893 | ////////////////////////////////////////////////////////////////////////////// | ||
3894 | // | ||
3895 | // bitmap baking | ||
3896 | // | ||
3897 | // This is SUPER-AWESOME (tm Ryan Gordon) packing using stb_rect_pack.h. If | ||
3898 | // stb_rect_pack.h isn't available, it uses the BakeFontBitmap strategy. | ||
3899 | |||
3900 | STBTT_DEF int stbtt_PackBegin(stbtt_pack_context *spc, unsigned char *pixels, int pw, int ph, int stride_in_bytes, int padding, void *alloc_context) | ||
3901 | { | ||
3902 | stbrp_context *context = (stbrp_context *) STBTT_malloc(sizeof(*context) ,alloc_context); | ||
3903 | int num_nodes = pw - padding; | ||
3904 | stbrp_node *nodes = (stbrp_node *) STBTT_malloc(sizeof(*nodes ) * num_nodes,alloc_context); | ||
3905 | |||
3906 | if (context == NULL || nodes == NULL) { | ||
3907 | if (context != NULL) STBTT_free(context, alloc_context); | ||
3908 | if (nodes != NULL) STBTT_free(nodes , alloc_context); | ||
3909 | return 0; | ||
3910 | } | ||
3911 | |||
3912 | spc->user_allocator_context = alloc_context; | ||
3913 | spc->width = pw; | ||
3914 | spc->height = ph; | ||
3915 | spc->pixels = pixels; | ||
3916 | spc->pack_info = context; | ||
3917 | spc->nodes = nodes; | ||
3918 | spc->padding = padding; | ||
3919 | spc->stride_in_bytes = stride_in_bytes != 0 ? stride_in_bytes : pw; | ||
3920 | spc->h_oversample = 1; | ||
3921 | spc->v_oversample = 1; | ||
3922 | spc->skip_missing = 0; | ||
3923 | |||
3924 | stbrp_init_target(context, pw-padding, ph-padding, nodes, num_nodes); | ||
3925 | |||
3926 | if (pixels) | ||
3927 | STBTT_memset(pixels, 0, pw*ph); // background of 0 around pixels | ||
3928 | |||
3929 | return 1; | ||
3930 | } | ||
3931 | |||
3932 | STBTT_DEF void stbtt_PackEnd (stbtt_pack_context *spc) | ||
3933 | { | ||
3934 | STBTT_free(spc->nodes , spc->user_allocator_context); | ||
3935 | STBTT_free(spc->pack_info, spc->user_allocator_context); | ||
3936 | } | ||
3937 | |||
3938 | STBTT_DEF void stbtt_PackSetOversampling(stbtt_pack_context *spc, unsigned int h_oversample, unsigned int v_oversample) | ||
3939 | { | ||
3940 | STBTT_assert(h_oversample <= STBTT_MAX_OVERSAMPLE); | ||
3941 | STBTT_assert(v_oversample <= STBTT_MAX_OVERSAMPLE); | ||
3942 | if (h_oversample <= STBTT_MAX_OVERSAMPLE) | ||
3943 | spc->h_oversample = h_oversample; | ||
3944 | if (v_oversample <= STBTT_MAX_OVERSAMPLE) | ||
3945 | spc->v_oversample = v_oversample; | ||
3946 | } | ||
3947 | |||
3948 | STBTT_DEF void stbtt_PackSetSkipMissingCodepoints(stbtt_pack_context *spc, int skip) | ||
3949 | { | ||
3950 | spc->skip_missing = skip; | ||
3951 | } | ||
3952 | |||
3953 | #define STBTT__OVER_MASK (STBTT_MAX_OVERSAMPLE-1) | ||
3954 | |||
3955 | static void stbtt__h_prefilter(unsigned char *pixels, int w, int h, int stride_in_bytes, unsigned int kernel_width) | ||
3956 | { | ||
3957 | unsigned char buffer[STBTT_MAX_OVERSAMPLE]; | ||
3958 | int safe_w = w - kernel_width; | ||
3959 | int j; | ||
3960 | STBTT_memset(buffer, 0, STBTT_MAX_OVERSAMPLE); // suppress bogus warning from VS2013 -analyze | ||
3961 | for (j=0; j < h; ++j) { | ||
3962 | int i; | ||
3963 | unsigned int total; | ||
3964 | STBTT_memset(buffer, 0, kernel_width); | ||
3965 | |||
3966 | total = 0; | ||
3967 | |||
3968 | // make kernel_width a constant in common cases so compiler can optimize out the divide | ||
3969 | switch (kernel_width) { | ||
3970 | case 2: | ||
3971 | for (i=0; i <= safe_w; ++i) { | ||
3972 | total += pixels[i] - buffer[i & STBTT__OVER_MASK]; | ||
3973 | buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i]; | ||
3974 | pixels[i] = (unsigned char) (total / 2); | ||
3975 | } | ||
3976 | break; | ||
3977 | case 3: | ||
3978 | for (i=0; i <= safe_w; ++i) { | ||
3979 | total += pixels[i] - buffer[i & STBTT__OVER_MASK]; | ||
3980 | buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i]; | ||
3981 | pixels[i] = (unsigned char) (total / 3); | ||
3982 | } | ||
3983 | break; | ||
3984 | case 4: | ||
3985 | for (i=0; i <= safe_w; ++i) { | ||
3986 | total += pixels[i] - buffer[i & STBTT__OVER_MASK]; | ||
3987 | buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i]; | ||
3988 | pixels[i] = (unsigned char) (total / 4); | ||
3989 | } | ||
3990 | break; | ||
3991 | case 5: | ||
3992 | for (i=0; i <= safe_w; ++i) { | ||
3993 | total += pixels[i] - buffer[i & STBTT__OVER_MASK]; | ||
3994 | buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i]; | ||
3995 | pixels[i] = (unsigned char) (total / 5); | ||
3996 | } | ||
3997 | break; | ||
3998 | default: | ||
3999 | for (i=0; i <= safe_w; ++i) { | ||
4000 | total += pixels[i] - buffer[i & STBTT__OVER_MASK]; | ||
4001 | buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i]; | ||
4002 | pixels[i] = (unsigned char) (total / kernel_width); | ||
4003 | } | ||
4004 | break; | ||
4005 | } | ||
4006 | |||
4007 | for (; i < w; ++i) { | ||
4008 | STBTT_assert(pixels[i] == 0); | ||
4009 | total -= buffer[i & STBTT__OVER_MASK]; | ||
4010 | pixels[i] = (unsigned char) (total / kernel_width); | ||
4011 | } | ||
4012 | |||
4013 | pixels += stride_in_bytes; | ||
4014 | } | ||
4015 | } | ||
4016 | |||
4017 | static void stbtt__v_prefilter(unsigned char *pixels, int w, int h, int stride_in_bytes, unsigned int kernel_width) | ||
4018 | { | ||
4019 | unsigned char buffer[STBTT_MAX_OVERSAMPLE]; | ||
4020 | int safe_h = h - kernel_width; | ||
4021 | int j; | ||
4022 | STBTT_memset(buffer, 0, STBTT_MAX_OVERSAMPLE); // suppress bogus warning from VS2013 -analyze | ||
4023 | for (j=0; j < w; ++j) { | ||
4024 | int i; | ||
4025 | unsigned int total; | ||
4026 | STBTT_memset(buffer, 0, kernel_width); | ||
4027 | |||
4028 | total = 0; | ||
4029 | |||
4030 | // make kernel_width a constant in common cases so compiler can optimize out the divide | ||
4031 | switch (kernel_width) { | ||
4032 | case 2: | ||
4033 | for (i=0; i <= safe_h; ++i) { | ||
4034 | total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK]; | ||
4035 | buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes]; | ||
4036 | pixels[i*stride_in_bytes] = (unsigned char) (total / 2); | ||
4037 | } | ||
4038 | break; | ||
4039 | case 3: | ||
4040 | for (i=0; i <= safe_h; ++i) { | ||
4041 | total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK]; | ||
4042 | buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes]; | ||
4043 | pixels[i*stride_in_bytes] = (unsigned char) (total / 3); | ||
4044 | } | ||
4045 | break; | ||
4046 | case 4: | ||
4047 | for (i=0; i <= safe_h; ++i) { | ||
4048 | total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK]; | ||
4049 | buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes]; | ||
4050 | pixels[i*stride_in_bytes] = (unsigned char) (total / 4); | ||
4051 | } | ||
4052 | break; | ||
4053 | case 5: | ||
4054 | for (i=0; i <= safe_h; ++i) { | ||
4055 | total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK]; | ||
4056 | buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes]; | ||
4057 | pixels[i*stride_in_bytes] = (unsigned char) (total / 5); | ||
4058 | } | ||
4059 | break; | ||
4060 | default: | ||
4061 | for (i=0; i <= safe_h; ++i) { | ||
4062 | total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK]; | ||
4063 | buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes]; | ||
4064 | pixels[i*stride_in_bytes] = (unsigned char) (total / kernel_width); | ||
4065 | } | ||
4066 | break; | ||
4067 | } | ||
4068 | |||
4069 | for (; i < h; ++i) { | ||
4070 | STBTT_assert(pixels[i*stride_in_bytes] == 0); | ||
4071 | total -= buffer[i & STBTT__OVER_MASK]; | ||
4072 | pixels[i*stride_in_bytes] = (unsigned char) (total / kernel_width); | ||
4073 | } | ||
4074 | |||
4075 | pixels += 1; | ||
4076 | } | ||
4077 | } | ||
4078 | |||
4079 | static float stbtt__oversample_shift(int oversample) | ||
4080 | { | ||
4081 | if (!oversample) | ||
4082 | return 0.0f; | ||
4083 | |||
4084 | // The prefilter is a box filter of width "oversample", | ||
4085 | // which shifts phase by (oversample - 1)/2 pixels in | ||
4086 | // oversampled space. We want to shift in the opposite | ||
4087 | // direction to counter this. | ||
4088 | return (float)-(oversample - 1) / (2.0f * (float)oversample); | ||
4089 | } | ||
4090 | |||
4091 | // rects array must be big enough to accommodate all characters in the given ranges | ||
4092 | STBTT_DEF int stbtt_PackFontRangesGatherRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects) | ||
4093 | { | ||
4094 | int i,j,k; | ||
4095 | int missing_glyph_added = 0; | ||
4096 | |||
4097 | k=0; | ||
4098 | for (i=0; i < num_ranges; ++i) { | ||
4099 | float fh = ranges[i].font_size; | ||
4100 | float scale = fh > 0 ? stbtt_ScaleForPixelHeight(info, fh) : stbtt_ScaleForMappingEmToPixels(info, -fh); | ||
4101 | ranges[i].h_oversample = (unsigned char) spc->h_oversample; | ||
4102 | ranges[i].v_oversample = (unsigned char) spc->v_oversample; | ||
4103 | for (j=0; j < ranges[i].num_chars; ++j) { | ||
4104 | int x0,y0,x1,y1; | ||
4105 | int codepoint = ranges[i].array_of_unicode_codepoints == NULL ? ranges[i].first_unicode_codepoint_in_range + j : ranges[i].array_of_unicode_codepoints[j]; | ||
4106 | int glyph = stbtt_FindGlyphIndex(info, codepoint); | ||
4107 | if (glyph == 0 && (spc->skip_missing || missing_glyph_added)) { | ||
4108 | rects[k].w = rects[k].h = 0; | ||
4109 | } else { | ||
4110 | stbtt_GetGlyphBitmapBoxSubpixel(info,glyph, | ||
4111 | scale * spc->h_oversample, | ||
4112 | scale * spc->v_oversample, | ||
4113 | 0,0, | ||
4114 | &x0,&y0,&x1,&y1); | ||
4115 | rects[k].w = (stbrp_coord) (x1-x0 + spc->padding + spc->h_oversample-1); | ||
4116 | rects[k].h = (stbrp_coord) (y1-y0 + spc->padding + spc->v_oversample-1); | ||
4117 | if (glyph == 0) | ||
4118 | missing_glyph_added = 1; | ||
4119 | } | ||
4120 | ++k; | ||
4121 | } | ||
4122 | } | ||
4123 | |||
4124 | return k; | ||
4125 | } | ||
4126 | |||
4127 | STBTT_DEF void stbtt_MakeGlyphBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int prefilter_x, int prefilter_y, float *sub_x, float *sub_y, int glyph) | ||
4128 | { | ||
4129 | stbtt_MakeGlyphBitmapSubpixel(info, | ||
4130 | output, | ||
4131 | out_w - (prefilter_x - 1), | ||
4132 | out_h - (prefilter_y - 1), | ||
4133 | out_stride, | ||
4134 | scale_x, | ||
4135 | scale_y, | ||
4136 | shift_x, | ||
4137 | shift_y, | ||
4138 | glyph); | ||
4139 | |||
4140 | if (prefilter_x > 1) | ||
4141 | stbtt__h_prefilter(output, out_w, out_h, out_stride, prefilter_x); | ||
4142 | |||
4143 | if (prefilter_y > 1) | ||
4144 | stbtt__v_prefilter(output, out_w, out_h, out_stride, prefilter_y); | ||
4145 | |||
4146 | *sub_x = stbtt__oversample_shift(prefilter_x); | ||
4147 | *sub_y = stbtt__oversample_shift(prefilter_y); | ||
4148 | } | ||
4149 | |||
4150 | // rects array must be big enough to accommodate all characters in the given ranges | ||
4151 | STBTT_DEF int stbtt_PackFontRangesRenderIntoRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects) | ||
4152 | { | ||
4153 | int i,j,k, missing_glyph = -1, return_value = 1; | ||
4154 | |||
4155 | // save current values | ||
4156 | int old_h_over = spc->h_oversample; | ||
4157 | int old_v_over = spc->v_oversample; | ||
4158 | |||
4159 | k = 0; | ||
4160 | for (i=0; i < num_ranges; ++i) { | ||
4161 | float fh = ranges[i].font_size; | ||
4162 | float scale = fh > 0 ? stbtt_ScaleForPixelHeight(info, fh) : stbtt_ScaleForMappingEmToPixels(info, -fh); | ||
4163 | float recip_h,recip_v,sub_x,sub_y; | ||
4164 | spc->h_oversample = ranges[i].h_oversample; | ||
4165 | spc->v_oversample = ranges[i].v_oversample; | ||
4166 | recip_h = 1.0f / spc->h_oversample; | ||
4167 | recip_v = 1.0f / spc->v_oversample; | ||
4168 | sub_x = stbtt__oversample_shift(spc->h_oversample); | ||
4169 | sub_y = stbtt__oversample_shift(spc->v_oversample); | ||
4170 | for (j=0; j < ranges[i].num_chars; ++j) { | ||
4171 | stbrp_rect *r = &rects[k]; | ||
4172 | if (r->was_packed && r->w != 0 && r->h != 0) { | ||
4173 | stbtt_packedchar *bc = &ranges[i].chardata_for_range[j]; | ||
4174 | int advance, lsb, x0,y0,x1,y1; | ||
4175 | int codepoint = ranges[i].array_of_unicode_codepoints == NULL ? ranges[i].first_unicode_codepoint_in_range + j : ranges[i].array_of_unicode_codepoints[j]; | ||
4176 | int glyph = stbtt_FindGlyphIndex(info, codepoint); | ||
4177 | stbrp_coord pad = (stbrp_coord) spc->padding; | ||
4178 | |||
4179 | // pad on left and top | ||
4180 | r->x += pad; | ||
4181 | r->y += pad; | ||
4182 | r->w -= pad; | ||
4183 | r->h -= pad; | ||
4184 | stbtt_GetGlyphHMetrics(info, glyph, &advance, &lsb); | ||
4185 | stbtt_GetGlyphBitmapBox(info, glyph, | ||
4186 | scale * spc->h_oversample, | ||
4187 | scale * spc->v_oversample, | ||
4188 | &x0,&y0,&x1,&y1); | ||
4189 | stbtt_MakeGlyphBitmapSubpixel(info, | ||
4190 | spc->pixels + r->x + r->y*spc->stride_in_bytes, | ||
4191 | r->w - spc->h_oversample+1, | ||
4192 | r->h - spc->v_oversample+1, | ||
4193 | spc->stride_in_bytes, | ||
4194 | scale * spc->h_oversample, | ||
4195 | scale * spc->v_oversample, | ||
4196 | 0,0, | ||
4197 | glyph); | ||
4198 | |||
4199 | if (spc->h_oversample > 1) | ||
4200 | stbtt__h_prefilter(spc->pixels + r->x + r->y*spc->stride_in_bytes, | ||
4201 | r->w, r->h, spc->stride_in_bytes, | ||
4202 | spc->h_oversample); | ||
4203 | |||
4204 | if (spc->v_oversample > 1) | ||
4205 | stbtt__v_prefilter(spc->pixels + r->x + r->y*spc->stride_in_bytes, | ||
4206 | r->w, r->h, spc->stride_in_bytes, | ||
4207 | spc->v_oversample); | ||
4208 | |||
4209 | bc->x0 = (stbtt_int16) r->x; | ||
4210 | bc->y0 = (stbtt_int16) r->y; | ||
4211 | bc->x1 = (stbtt_int16) (r->x + r->w); | ||
4212 | bc->y1 = (stbtt_int16) (r->y + r->h); | ||
4213 | bc->xadvance = scale * advance; | ||
4214 | bc->xoff = (float) x0 * recip_h + sub_x; | ||
4215 | bc->yoff = (float) y0 * recip_v + sub_y; | ||
4216 | bc->xoff2 = (x0 + r->w) * recip_h + sub_x; | ||
4217 | bc->yoff2 = (y0 + r->h) * recip_v + sub_y; | ||
4218 | |||
4219 | if (glyph == 0) | ||
4220 | missing_glyph = j; | ||
4221 | } else if (spc->skip_missing) { | ||
4222 | return_value = 0; | ||
4223 | } else if (r->was_packed && r->w == 0 && r->h == 0 && missing_glyph >= 0) { | ||
4224 | ranges[i].chardata_for_range[j] = ranges[i].chardata_for_range[missing_glyph]; | ||
4225 | } else { | ||
4226 | return_value = 0; // if any fail, report failure | ||
4227 | } | ||
4228 | |||
4229 | ++k; | ||
4230 | } | ||
4231 | } | ||
4232 | |||
4233 | // restore original values | ||
4234 | spc->h_oversample = old_h_over; | ||
4235 | spc->v_oversample = old_v_over; | ||
4236 | |||
4237 | return return_value; | ||
4238 | } | ||
4239 | |||
4240 | STBTT_DEF void stbtt_PackFontRangesPackRects(stbtt_pack_context *spc, stbrp_rect *rects, int num_rects) | ||
4241 | { | ||
4242 | stbrp_pack_rects((stbrp_context *) spc->pack_info, rects, num_rects); | ||
4243 | } | ||
4244 | |||
4245 | STBTT_DEF int stbtt_PackFontRanges(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, stbtt_pack_range *ranges, int num_ranges) | ||
4246 | { | ||
4247 | stbtt_fontinfo info; | ||
4248 | int i,j,n, return_value = 1; | ||
4249 | //stbrp_context *context = (stbrp_context *) spc->pack_info; | ||
4250 | stbrp_rect *rects; | ||
4251 | |||
4252 | // flag all characters as NOT packed | ||
4253 | for (i=0; i < num_ranges; ++i) | ||
4254 | for (j=0; j < ranges[i].num_chars; ++j) | ||
4255 | ranges[i].chardata_for_range[j].x0 = | ||
4256 | ranges[i].chardata_for_range[j].y0 = | ||
4257 | ranges[i].chardata_for_range[j].x1 = | ||
4258 | ranges[i].chardata_for_range[j].y1 = 0; | ||
4259 | |||
4260 | n = 0; | ||
4261 | for (i=0; i < num_ranges; ++i) | ||
4262 | n += ranges[i].num_chars; | ||
4263 | |||
4264 | rects = (stbrp_rect *) STBTT_malloc(sizeof(*rects) * n, spc->user_allocator_context); | ||
4265 | if (rects == NULL) | ||
4266 | return 0; | ||
4267 | |||
4268 | info.userdata = spc->user_allocator_context; | ||
4269 | stbtt_InitFont(&info, fontdata, stbtt_GetFontOffsetForIndex(fontdata,font_index)); | ||
4270 | |||
4271 | n = stbtt_PackFontRangesGatherRects(spc, &info, ranges, num_ranges, rects); | ||
4272 | |||
4273 | stbtt_PackFontRangesPackRects(spc, rects, n); | ||
4274 | |||
4275 | return_value = stbtt_PackFontRangesRenderIntoRects(spc, &info, ranges, num_ranges, rects); | ||
4276 | |||
4277 | STBTT_free(rects, spc->user_allocator_context); | ||
4278 | return return_value; | ||
4279 | } | ||
4280 | |||
4281 | STBTT_DEF int stbtt_PackFontRange(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, float font_size, | ||
4282 | int first_unicode_codepoint_in_range, int num_chars_in_range, stbtt_packedchar *chardata_for_range) | ||
4283 | { | ||
4284 | stbtt_pack_range range; | ||
4285 | range.first_unicode_codepoint_in_range = first_unicode_codepoint_in_range; | ||
4286 | range.array_of_unicode_codepoints = NULL; | ||
4287 | range.num_chars = num_chars_in_range; | ||
4288 | range.chardata_for_range = chardata_for_range; | ||
4289 | range.font_size = font_size; | ||
4290 | return stbtt_PackFontRanges(spc, fontdata, font_index, &range, 1); | ||
4291 | } | ||
4292 | |||
4293 | STBTT_DEF void stbtt_GetScaledFontVMetrics(const unsigned char *fontdata, int index, float size, float *ascent, float *descent, float *lineGap) | ||
4294 | { | ||
4295 | int i_ascent, i_descent, i_lineGap; | ||
4296 | float scale; | ||
4297 | stbtt_fontinfo info; | ||
4298 | stbtt_InitFont(&info, fontdata, stbtt_GetFontOffsetForIndex(fontdata, index)); | ||
4299 | scale = size > 0 ? stbtt_ScaleForPixelHeight(&info, size) : stbtt_ScaleForMappingEmToPixels(&info, -size); | ||
4300 | stbtt_GetFontVMetrics(&info, &i_ascent, &i_descent, &i_lineGap); | ||
4301 | *ascent = (float) i_ascent * scale; | ||
4302 | *descent = (float) i_descent * scale; | ||
4303 | *lineGap = (float) i_lineGap * scale; | ||
4304 | } | ||
4305 | |||
4306 | STBTT_DEF void stbtt_GetPackedQuad(const stbtt_packedchar *chardata, int pw, int ph, int char_index, float *xpos, float *ypos, stbtt_aligned_quad *q, int align_to_integer) | ||
4307 | { | ||
4308 | float ipw = 1.0f / pw, iph = 1.0f / ph; | ||
4309 | const stbtt_packedchar *b = chardata + char_index; | ||
4310 | |||
4311 | if (align_to_integer) { | ||
4312 | float x = (float) STBTT_ifloor((*xpos + b->xoff) + 0.5f); | ||
4313 | float y = (float) STBTT_ifloor((*ypos + b->yoff) + 0.5f); | ||
4314 | q->x0 = x; | ||
4315 | q->y0 = y; | ||
4316 | q->x1 = x + b->xoff2 - b->xoff; | ||
4317 | q->y1 = y + b->yoff2 - b->yoff; | ||
4318 | } else { | ||
4319 | q->x0 = *xpos + b->xoff; | ||
4320 | q->y0 = *ypos + b->yoff; | ||
4321 | q->x1 = *xpos + b->xoff2; | ||
4322 | q->y1 = *ypos + b->yoff2; | ||
4323 | } | ||
4324 | |||
4325 | q->s0 = b->x0 * ipw; | ||
4326 | q->t0 = b->y0 * iph; | ||
4327 | q->s1 = b->x1 * ipw; | ||
4328 | q->t1 = b->y1 * iph; | ||
4329 | |||
4330 | *xpos += b->xadvance; | ||
4331 | } | ||
4332 | |||
4333 | ////////////////////////////////////////////////////////////////////////////// | ||
4334 | // | ||
4335 | // sdf computation | ||
4336 | // | ||
4337 | |||
4338 | #define STBTT_min(a,b) ((a) < (b) ? (a) : (b)) | ||
4339 | #define STBTT_max(a,b) ((a) < (b) ? (b) : (a)) | ||
4340 | |||
4341 | static int stbtt__ray_intersect_bezier(float orig[2], float ray[2], float q0[2], float q1[2], float q2[2], float hits[2][2]) | ||
4342 | { | ||
4343 | float q0perp = q0[1]*ray[0] - q0[0]*ray[1]; | ||
4344 | float q1perp = q1[1]*ray[0] - q1[0]*ray[1]; | ||
4345 | float q2perp = q2[1]*ray[0] - q2[0]*ray[1]; | ||
4346 | float roperp = orig[1]*ray[0] - orig[0]*ray[1]; | ||
4347 | |||
4348 | float a = q0perp - 2*q1perp + q2perp; | ||
4349 | float b = q1perp - q0perp; | ||
4350 | float c = q0perp - roperp; | ||
4351 | |||
4352 | float s0 = 0., s1 = 0.; | ||
4353 | int num_s = 0; | ||
4354 | |||
4355 | if (a != 0.0) { | ||
4356 | float discr = b*b - a*c; | ||
4357 | if (discr > 0.0) { | ||
4358 | float rcpna = -1 / a; | ||
4359 | float d = (float) STBTT_sqrt(discr); | ||
4360 | s0 = (b+d) * rcpna; | ||
4361 | s1 = (b-d) * rcpna; | ||
4362 | if (s0 >= 0.0 && s0 <= 1.0) | ||
4363 | num_s = 1; | ||
4364 | if (d > 0.0 && s1 >= 0.0 && s1 <= 1.0) { | ||
4365 | if (num_s == 0) s0 = s1; | ||
4366 | ++num_s; | ||
4367 | } | ||
4368 | } | ||
4369 | } else { | ||
4370 | // 2*b*s + c = 0 | ||
4371 | // s = -c / (2*b) | ||
4372 | s0 = c / (-2 * b); | ||
4373 | if (s0 >= 0.0 && s0 <= 1.0) | ||
4374 | num_s = 1; | ||
4375 | } | ||
4376 | |||
4377 | if (num_s == 0) | ||
4378 | return 0; | ||
4379 | else { | ||
4380 | float rcp_len2 = 1 / (ray[0]*ray[0] + ray[1]*ray[1]); | ||
4381 | float rayn_x = ray[0] * rcp_len2, rayn_y = ray[1] * rcp_len2; | ||
4382 | |||
4383 | float q0d = q0[0]*rayn_x + q0[1]*rayn_y; | ||
4384 | float q1d = q1[0]*rayn_x + q1[1]*rayn_y; | ||
4385 | float q2d = q2[0]*rayn_x + q2[1]*rayn_y; | ||
4386 | float rod = orig[0]*rayn_x + orig[1]*rayn_y; | ||
4387 | |||
4388 | float q10d = q1d - q0d; | ||
4389 | float q20d = q2d - q0d; | ||
4390 | float q0rd = q0d - rod; | ||
4391 | |||
4392 | hits[0][0] = q0rd + s0*(2.0f - 2.0f*s0)*q10d + s0*s0*q20d; | ||
4393 | hits[0][1] = a*s0+b; | ||
4394 | |||
4395 | if (num_s > 1) { | ||
4396 | hits[1][0] = q0rd + s1*(2.0f - 2.0f*s1)*q10d + s1*s1*q20d; | ||
4397 | hits[1][1] = a*s1+b; | ||
4398 | return 2; | ||
4399 | } else { | ||
4400 | return 1; | ||
4401 | } | ||
4402 | } | ||
4403 | } | ||
4404 | |||
4405 | static int equal(float *a, float *b) | ||
4406 | { | ||
4407 | return (a[0] == b[0] && a[1] == b[1]); | ||
4408 | } | ||
4409 | |||
4410 | static int stbtt__compute_crossings_x(float x, float y, int nverts, stbtt_vertex *verts) | ||
4411 | { | ||
4412 | int i; | ||
4413 | float orig[2], ray[2] = { 1, 0 }; | ||
4414 | float y_frac; | ||
4415 | int winding = 0; | ||
4416 | |||
4417 | orig[0] = x; | ||
4418 | orig[1] = y; | ||
4419 | |||
4420 | // make sure y never passes through a vertex of the shape | ||
4421 | y_frac = (float) STBTT_fmod(y, 1.0f); | ||
4422 | if (y_frac < 0.01f) | ||
4423 | y += 0.01f; | ||
4424 | else if (y_frac > 0.99f) | ||
4425 | y -= 0.01f; | ||
4426 | orig[1] = y; | ||
4427 | |||
4428 | // test a ray from (-infinity,y) to (x,y) | ||
4429 | for (i=0; i < nverts; ++i) { | ||
4430 | if (verts[i].type == STBTT_vline) { | ||
4431 | int x0 = (int) verts[i-1].x, y0 = (int) verts[i-1].y; | ||
4432 | int x1 = (int) verts[i ].x, y1 = (int) verts[i ].y; | ||
4433 | if (y > STBTT_min(y0,y1) && y < STBTT_max(y0,y1) && x > STBTT_min(x0,x1)) { | ||
4434 | float x_inter = (y - y0) / (y1 - y0) * (x1-x0) + x0; | ||
4435 | if (x_inter < x) | ||
4436 | winding += (y0 < y1) ? 1 : -1; | ||
4437 | } | ||
4438 | } | ||
4439 | if (verts[i].type == STBTT_vcurve) { | ||
4440 | int x0 = (int) verts[i-1].x , y0 = (int) verts[i-1].y ; | ||
4441 | int x1 = (int) verts[i ].cx, y1 = (int) verts[i ].cy; | ||
4442 | int x2 = (int) verts[i ].x , y2 = (int) verts[i ].y ; | ||
4443 | int ax = STBTT_min(x0,STBTT_min(x1,x2)), ay = STBTT_min(y0,STBTT_min(y1,y2)); | ||
4444 | int by = STBTT_max(y0,STBTT_max(y1,y2)); | ||
4445 | if (y > ay && y < by && x > ax) { | ||
4446 | float q0[2],q1[2],q2[2]; | ||
4447 | float hits[2][2]; | ||
4448 | q0[0] = (float)x0; | ||
4449 | q0[1] = (float)y0; | ||
4450 | q1[0] = (float)x1; | ||
4451 | q1[1] = (float)y1; | ||
4452 | q2[0] = (float)x2; | ||
4453 | q2[1] = (float)y2; | ||
4454 | if (equal(q0,q1) || equal(q1,q2)) { | ||
4455 | x0 = (int)verts[i-1].x; | ||
4456 | y0 = (int)verts[i-1].y; | ||
4457 | x1 = (int)verts[i ].x; | ||
4458 | y1 = (int)verts[i ].y; | ||
4459 | if (y > STBTT_min(y0,y1) && y < STBTT_max(y0,y1) && x > STBTT_min(x0,x1)) { | ||
4460 | float x_inter = (y - y0) / (y1 - y0) * (x1-x0) + x0; | ||
4461 | if (x_inter < x) | ||
4462 | winding += (y0 < y1) ? 1 : -1; | ||
4463 | } | ||
4464 | } else { | ||
4465 | int num_hits = stbtt__ray_intersect_bezier(orig, ray, q0, q1, q2, hits); | ||
4466 | if (num_hits >= 1) | ||
4467 | if (hits[0][0] < 0) | ||
4468 | winding += (hits[0][1] < 0 ? -1 : 1); | ||
4469 | if (num_hits >= 2) | ||
4470 | if (hits[1][0] < 0) | ||
4471 | winding += (hits[1][1] < 0 ? -1 : 1); | ||
4472 | } | ||
4473 | } | ||
4474 | } | ||
4475 | } | ||
4476 | return winding; | ||
4477 | } | ||
4478 | |||
4479 | static float stbtt__cuberoot( float x ) | ||
4480 | { | ||
4481 | if (x<0) | ||
4482 | return -(float) STBTT_pow(-x,1.0f/3.0f); | ||
4483 | else | ||
4484 | return (float) STBTT_pow( x,1.0f/3.0f); | ||
4485 | } | ||
4486 | |||
4487 | // x^3 + c*x^2 + b*x + a = 0 | ||
4488 | static int stbtt__solve_cubic(float a, float b, float c, float* r) | ||
4489 | { | ||
4490 | float s = -a / 3; | ||
4491 | float p = b - a*a / 3; | ||
4492 | float q = a * (2*a*a - 9*b) / 27 + c; | ||
4493 | float p3 = p*p*p; | ||
4494 | float d = q*q + 4*p3 / 27; | ||
4495 | if (d >= 0) { | ||
4496 | float z = (float) STBTT_sqrt(d); | ||
4497 | float u = (-q + z) / 2; | ||
4498 | float v = (-q - z) / 2; | ||
4499 | u = stbtt__cuberoot(u); | ||
4500 | v = stbtt__cuberoot(v); | ||
4501 | r[0] = s + u + v; | ||
4502 | return 1; | ||
4503 | } else { | ||
4504 | float u = (float) STBTT_sqrt(-p/3); | ||
4505 | float v = (float) STBTT_acos(-STBTT_sqrt(-27/p3) * q / 2) / 3; // p3 must be negative, since d is negative | ||
4506 | float m = (float) STBTT_cos(v); | ||
4507 | float n = (float) STBTT_cos(v-3.141592/2)*1.732050808f; | ||
4508 | r[0] = s + u * 2 * m; | ||
4509 | r[1] = s - u * (m + n); | ||
4510 | r[2] = s - u * (m - n); | ||
4511 | |||
4512 | //STBTT_assert( STBTT_fabs(((r[0]+a)*r[0]+b)*r[0]+c) < 0.05f); // these asserts may not be safe at all scales, though they're in bezier t parameter units so maybe? | ||
4513 | //STBTT_assert( STBTT_fabs(((r[1]+a)*r[1]+b)*r[1]+c) < 0.05f); | ||
4514 | //STBTT_assert( STBTT_fabs(((r[2]+a)*r[2]+b)*r[2]+c) < 0.05f); | ||
4515 | return 3; | ||
4516 | } | ||
4517 | } | ||
4518 | |||
4519 | STBTT_DEF unsigned char * stbtt_GetGlyphSDF(const stbtt_fontinfo *info, float scale, int glyph, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff) | ||
4520 | { | ||
4521 | float scale_x = scale, scale_y = scale; | ||
4522 | int ix0,iy0,ix1,iy1; | ||
4523 | int w,h; | ||
4524 | unsigned char *data; | ||
4525 | |||
4526 | if (scale == 0) return NULL; | ||
4527 | |||
4528 | stbtt_GetGlyphBitmapBoxSubpixel(info, glyph, scale, scale, 0.0f,0.0f, &ix0,&iy0,&ix1,&iy1); | ||
4529 | |||
4530 | // if empty, return NULL | ||
4531 | if (ix0 == ix1 || iy0 == iy1) | ||
4532 | return NULL; | ||
4533 | |||
4534 | ix0 -= padding; | ||
4535 | iy0 -= padding; | ||
4536 | ix1 += padding; | ||
4537 | iy1 += padding; | ||
4538 | |||
4539 | w = (ix1 - ix0); | ||
4540 | h = (iy1 - iy0); | ||
4541 | |||
4542 | if (width ) *width = w; | ||
4543 | if (height) *height = h; | ||
4544 | if (xoff ) *xoff = ix0; | ||
4545 | if (yoff ) *yoff = iy0; | ||
4546 | |||
4547 | // invert for y-downwards bitmaps | ||
4548 | scale_y = -scale_y; | ||
4549 | |||
4550 | { | ||
4551 | int x,y,i,j; | ||
4552 | float *precompute; | ||
4553 | stbtt_vertex *verts; | ||
4554 | int num_verts = stbtt_GetGlyphShape(info, glyph, &verts); | ||
4555 | data = (unsigned char *) STBTT_malloc(w * h, info->userdata); | ||
4556 | precompute = (float *) STBTT_malloc(num_verts * sizeof(float), info->userdata); | ||
4557 | |||
4558 | for (i=0,j=num_verts-1; i < num_verts; j=i++) { | ||
4559 | if (verts[i].type == STBTT_vline) { | ||
4560 | float x0 = verts[i].x*scale_x, y0 = verts[i].y*scale_y; | ||
4561 | float x1 = verts[j].x*scale_x, y1 = verts[j].y*scale_y; | ||
4562 | float dist = (float) STBTT_sqrt((x1-x0)*(x1-x0) + (y1-y0)*(y1-y0)); | ||
4563 | precompute[i] = (dist == 0) ? 0.0f : 1.0f / dist; | ||
4564 | } else if (verts[i].type == STBTT_vcurve) { | ||
4565 | float x2 = verts[j].x *scale_x, y2 = verts[j].y *scale_y; | ||
4566 | float x1 = verts[i].cx*scale_x, y1 = verts[i].cy*scale_y; | ||
4567 | float x0 = verts[i].x *scale_x, y0 = verts[i].y *scale_y; | ||
4568 | float bx = x0 - 2*x1 + x2, by = y0 - 2*y1 + y2; | ||
4569 | float len2 = bx*bx + by*by; | ||
4570 | if (len2 != 0.0f) | ||
4571 | precompute[i] = 1.0f / (bx*bx + by*by); | ||
4572 | else | ||
4573 | precompute[i] = 0.0f; | ||
4574 | } else | ||
4575 | precompute[i] = 0.0f; | ||
4576 | } | ||
4577 | |||
4578 | for (y=iy0; y < iy1; ++y) { | ||
4579 | for (x=ix0; x < ix1; ++x) { | ||
4580 | float val; | ||
4581 | float min_dist = 999999.0f; | ||
4582 | float sx = (float) x + 0.5f; | ||
4583 | float sy = (float) y + 0.5f; | ||
4584 | float x_gspace = (sx / scale_x); | ||
4585 | float y_gspace = (sy / scale_y); | ||
4586 | |||
4587 | int winding = stbtt__compute_crossings_x(x_gspace, y_gspace, num_verts, verts); // @OPTIMIZE: this could just be a rasterization, but needs to be line vs. non-tesselated curves so a new path | ||
4588 | |||
4589 | for (i=0; i < num_verts; ++i) { | ||
4590 | float x0 = verts[i].x*scale_x, y0 = verts[i].y*scale_y; | ||
4591 | |||
4592 | // check against every point here rather than inside line/curve primitives -- @TODO: wrong if multiple 'moves' in a row produce a garbage point, and given culling, probably more efficient to do within line/curve | ||
4593 | float dist2 = (x0-sx)*(x0-sx) + (y0-sy)*(y0-sy); | ||
4594 | if (dist2 < min_dist*min_dist) | ||
4595 | min_dist = (float) STBTT_sqrt(dist2); | ||
4596 | |||
4597 | if (verts[i].type == STBTT_vline) { | ||
4598 | float x1 = verts[i-1].x*scale_x, y1 = verts[i-1].y*scale_y; | ||
4599 | |||
4600 | // coarse culling against bbox | ||
4601 | //if (sx > STBTT_min(x0,x1)-min_dist && sx < STBTT_max(x0,x1)+min_dist && | ||
4602 | // sy > STBTT_min(y0,y1)-min_dist && sy < STBTT_max(y0,y1)+min_dist) | ||
4603 | float dist = (float) STBTT_fabs((x1-x0)*(y0-sy) - (y1-y0)*(x0-sx)) * precompute[i]; | ||
4604 | STBTT_assert(i != 0); | ||
4605 | if (dist < min_dist) { | ||
4606 | // check position along line | ||
4607 | // x' = x0 + t*(x1-x0), y' = y0 + t*(y1-y0) | ||
4608 | // minimize (x'-sx)*(x'-sx)+(y'-sy)*(y'-sy) | ||
4609 | float dx = x1-x0, dy = y1-y0; | ||
4610 | float px = x0-sx, py = y0-sy; | ||
4611 | // minimize (px+t*dx)^2 + (py+t*dy)^2 = px*px + 2*px*dx*t + t^2*dx*dx + py*py + 2*py*dy*t + t^2*dy*dy | ||
4612 | // derivative: 2*px*dx + 2*py*dy + (2*dx*dx+2*dy*dy)*t, set to 0 and solve | ||
4613 | float t = -(px*dx + py*dy) / (dx*dx + dy*dy); | ||
4614 | if (t >= 0.0f && t <= 1.0f) | ||
4615 | min_dist = dist; | ||
4616 | } | ||
4617 | } else if (verts[i].type == STBTT_vcurve) { | ||
4618 | float x2 = verts[i-1].x *scale_x, y2 = verts[i-1].y *scale_y; | ||
4619 | float x1 = verts[i ].cx*scale_x, y1 = verts[i ].cy*scale_y; | ||
4620 | float box_x0 = STBTT_min(STBTT_min(x0,x1),x2); | ||
4621 | float box_y0 = STBTT_min(STBTT_min(y0,y1),y2); | ||
4622 | float box_x1 = STBTT_max(STBTT_max(x0,x1),x2); | ||
4623 | float box_y1 = STBTT_max(STBTT_max(y0,y1),y2); | ||
4624 | // coarse culling against bbox to avoid computing cubic unnecessarily | ||
4625 | if (sx > box_x0-min_dist && sx < box_x1+min_dist && sy > box_y0-min_dist && sy < box_y1+min_dist) { | ||
4626 | int num=0; | ||
4627 | float ax = x1-x0, ay = y1-y0; | ||
4628 | float bx = x0 - 2*x1 + x2, by = y0 - 2*y1 + y2; | ||
4629 | float mx = x0 - sx, my = y0 - sy; | ||
4630 | float res[3],px,py,t,it; | ||
4631 | float a_inv = precompute[i]; | ||
4632 | if (a_inv == 0.0) { // if a_inv is 0, it's 2nd degree so use quadratic formula | ||
4633 | float a = 3*(ax*bx + ay*by); | ||
4634 | float b = 2*(ax*ax + ay*ay) + (mx*bx+my*by); | ||
4635 | float c = mx*ax+my*ay; | ||
4636 | if (a == 0.0) { // if a is 0, it's linear | ||
4637 | if (b != 0.0) { | ||
4638 | res[num++] = -c/b; | ||
4639 | } | ||
4640 | } else { | ||
4641 | float discriminant = b*b - 4*a*c; | ||
4642 | if (discriminant < 0) | ||
4643 | num = 0; | ||
4644 | else { | ||
4645 | float root = (float) STBTT_sqrt(discriminant); | ||
4646 | res[0] = (-b - root)/(2*a); | ||
4647 | res[1] = (-b + root)/(2*a); | ||
4648 | num = 2; // don't bother distinguishing 1-solution case, as code below will still work | ||
4649 | } | ||
4650 | } | ||
4651 | } else { | ||
4652 | float b = 3*(ax*bx + ay*by) * a_inv; // could precompute this as it doesn't depend on sample point | ||
4653 | float c = (2*(ax*ax + ay*ay) + (mx*bx+my*by)) * a_inv; | ||
4654 | float d = (mx*ax+my*ay) * a_inv; | ||
4655 | num = stbtt__solve_cubic(b, c, d, res); | ||
4656 | } | ||
4657 | if (num >= 1 && res[0] >= 0.0f && res[0] <= 1.0f) { | ||
4658 | t = res[0], it = 1.0f - t; | ||
4659 | px = it*it*x0 + 2*t*it*x1 + t*t*x2; | ||
4660 | py = it*it*y0 + 2*t*it*y1 + t*t*y2; | ||
4661 | dist2 = (px-sx)*(px-sx) + (py-sy)*(py-sy); | ||
4662 | if (dist2 < min_dist * min_dist) | ||
4663 | min_dist = (float) STBTT_sqrt(dist2); | ||
4664 | } | ||
4665 | if (num >= 2 && res[1] >= 0.0f && res[1] <= 1.0f) { | ||
4666 | t = res[1], it = 1.0f - t; | ||
4667 | px = it*it*x0 + 2*t*it*x1 + t*t*x2; | ||
4668 | py = it*it*y0 + 2*t*it*y1 + t*t*y2; | ||
4669 | dist2 = (px-sx)*(px-sx) + (py-sy)*(py-sy); | ||
4670 | if (dist2 < min_dist * min_dist) | ||
4671 | min_dist = (float) STBTT_sqrt(dist2); | ||
4672 | } | ||
4673 | if (num >= 3 && res[2] >= 0.0f && res[2] <= 1.0f) { | ||
4674 | t = res[2], it = 1.0f - t; | ||
4675 | px = it*it*x0 + 2*t*it*x1 + t*t*x2; | ||
4676 | py = it*it*y0 + 2*t*it*y1 + t*t*y2; | ||
4677 | dist2 = (px-sx)*(px-sx) + (py-sy)*(py-sy); | ||
4678 | if (dist2 < min_dist * min_dist) | ||
4679 | min_dist = (float) STBTT_sqrt(dist2); | ||
4680 | } | ||
4681 | } | ||
4682 | } | ||
4683 | } | ||
4684 | if (winding == 0) | ||
4685 | min_dist = -min_dist; // if outside the shape, value is negative | ||
4686 | val = onedge_value + pixel_dist_scale * min_dist; | ||
4687 | if (val < 0) | ||
4688 | val = 0; | ||
4689 | else if (val > 255) | ||
4690 | val = 255; | ||
4691 | data[(y-iy0)*w+(x-ix0)] = (unsigned char) val; | ||
4692 | } | ||
4693 | } | ||
4694 | STBTT_free(precompute, info->userdata); | ||
4695 | STBTT_free(verts, info->userdata); | ||
4696 | } | ||
4697 | return data; | ||
4698 | } | ||
4699 | |||
4700 | STBTT_DEF unsigned char * stbtt_GetCodepointSDF(const stbtt_fontinfo *info, float scale, int codepoint, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff) | ||
4701 | { | ||
4702 | return stbtt_GetGlyphSDF(info, scale, stbtt_FindGlyphIndex(info, codepoint), padding, onedge_value, pixel_dist_scale, width, height, xoff, yoff); | ||
4703 | } | ||
4704 | |||
4705 | STBTT_DEF void stbtt_FreeSDF(unsigned char *bitmap, void *userdata) | ||
4706 | { | ||
4707 | STBTT_free(bitmap, userdata); | ||
4708 | } | ||
4709 | |||
4710 | ////////////////////////////////////////////////////////////////////////////// | ||
4711 | // | ||
4712 | // font name matching -- recommended not to use this | ||
4713 | // | ||
4714 | |||
4715 | // check if a utf8 string contains a prefix which is the utf16 string; if so return length of matching utf8 string | ||
4716 | static stbtt_int32 stbtt__CompareUTF8toUTF16_bigendian_prefix(stbtt_uint8 *s1, stbtt_int32 len1, stbtt_uint8 *s2, stbtt_int32 len2) | ||
4717 | { | ||
4718 | stbtt_int32 i=0; | ||
4719 | |||
4720 | // convert utf16 to utf8 and compare the results while converting | ||
4721 | while (len2) { | ||
4722 | stbtt_uint16 ch = s2[0]*256 + s2[1]; | ||
4723 | if (ch < 0x80) { | ||
4724 | if (i >= len1) return -1; | ||
4725 | if (s1[i++] != ch) return -1; | ||
4726 | } else if (ch < 0x800) { | ||
4727 | if (i+1 >= len1) return -1; | ||
4728 | if (s1[i++] != 0xc0 + (ch >> 6)) return -1; | ||
4729 | if (s1[i++] != 0x80 + (ch & 0x3f)) return -1; | ||
4730 | } else if (ch >= 0xd800 && ch < 0xdc00) { | ||
4731 | stbtt_uint32 c; | ||
4732 | stbtt_uint16 ch2 = s2[2]*256 + s2[3]; | ||
4733 | if (i+3 >= len1) return -1; | ||
4734 | c = ((ch - 0xd800) << 10) + (ch2 - 0xdc00) + 0x10000; | ||
4735 | if (s1[i++] != 0xf0 + (c >> 18)) return -1; | ||
4736 | if (s1[i++] != 0x80 + ((c >> 12) & 0x3f)) return -1; | ||
4737 | if (s1[i++] != 0x80 + ((c >> 6) & 0x3f)) return -1; | ||
4738 | if (s1[i++] != 0x80 + ((c ) & 0x3f)) return -1; | ||
4739 | s2 += 2; // plus another 2 below | ||
4740 | len2 -= 2; | ||
4741 | } else if (ch >= 0xdc00 && ch < 0xe000) { | ||
4742 | return -1; | ||
4743 | } else { | ||
4744 | if (i+2 >= len1) return -1; | ||
4745 | if (s1[i++] != 0xe0 + (ch >> 12)) return -1; | ||
4746 | if (s1[i++] != 0x80 + ((ch >> 6) & 0x3f)) return -1; | ||
4747 | if (s1[i++] != 0x80 + ((ch ) & 0x3f)) return -1; | ||
4748 | } | ||
4749 | s2 += 2; | ||
4750 | len2 -= 2; | ||
4751 | } | ||
4752 | return i; | ||
4753 | } | ||
4754 | |||
4755 | static int stbtt_CompareUTF8toUTF16_bigendian_internal(char *s1, int len1, char *s2, int len2) | ||
4756 | { | ||
4757 | return len1 == stbtt__CompareUTF8toUTF16_bigendian_prefix((stbtt_uint8*) s1, len1, (stbtt_uint8*) s2, len2); | ||
4758 | } | ||
4759 | |||
4760 | // returns results in whatever encoding you request... but note that 2-byte encodings | ||
4761 | // will be BIG-ENDIAN... use stbtt_CompareUTF8toUTF16_bigendian() to compare | ||
4762 | STBTT_DEF const char *stbtt_GetFontNameString(const stbtt_fontinfo *font, int *length, int platformID, int encodingID, int languageID, int nameID) | ||
4763 | { | ||
4764 | stbtt_int32 i,count,stringOffset; | ||
4765 | stbtt_uint8 *fc = font->data; | ||
4766 | stbtt_uint32 offset = font->fontstart; | ||
4767 | stbtt_uint32 nm = stbtt__find_table(fc, offset, "name"); | ||
4768 | if (!nm) return NULL; | ||
4769 | |||
4770 | count = ttUSHORT(fc+nm+2); | ||
4771 | stringOffset = nm + ttUSHORT(fc+nm+4); | ||
4772 | for (i=0; i < count; ++i) { | ||
4773 | stbtt_uint32 loc = nm + 6 + 12 * i; | ||
4774 | if (platformID == ttUSHORT(fc+loc+0) && encodingID == ttUSHORT(fc+loc+2) | ||
4775 | && languageID == ttUSHORT(fc+loc+4) && nameID == ttUSHORT(fc+loc+6)) { | ||
4776 | *length = ttUSHORT(fc+loc+8); | ||
4777 | return (const char *) (fc+stringOffset+ttUSHORT(fc+loc+10)); | ||
4778 | } | ||
4779 | } | ||
4780 | return NULL; | ||
4781 | } | ||
4782 | |||
4783 | static int stbtt__matchpair(stbtt_uint8 *fc, stbtt_uint32 nm, stbtt_uint8 *name, stbtt_int32 nlen, stbtt_int32 target_id, stbtt_int32 next_id) | ||
4784 | { | ||
4785 | stbtt_int32 i; | ||
4786 | stbtt_int32 count = ttUSHORT(fc+nm+2); | ||
4787 | stbtt_int32 stringOffset = nm + ttUSHORT(fc+nm+4); | ||
4788 | |||
4789 | for (i=0; i < count; ++i) { | ||
4790 | stbtt_uint32 loc = nm + 6 + 12 * i; | ||
4791 | stbtt_int32 id = ttUSHORT(fc+loc+6); | ||
4792 | if (id == target_id) { | ||
4793 | // find the encoding | ||
4794 | stbtt_int32 platform = ttUSHORT(fc+loc+0), encoding = ttUSHORT(fc+loc+2), language = ttUSHORT(fc+loc+4); | ||
4795 | |||
4796 | // is this a Unicode encoding? | ||
4797 | if (platform == 0 || (platform == 3 && encoding == 1) || (platform == 3 && encoding == 10)) { | ||
4798 | stbtt_int32 slen = ttUSHORT(fc+loc+8); | ||
4799 | stbtt_int32 off = ttUSHORT(fc+loc+10); | ||
4800 | |||
4801 | // check if there's a prefix match | ||
4802 | stbtt_int32 matchlen = stbtt__CompareUTF8toUTF16_bigendian_prefix(name, nlen, fc+stringOffset+off,slen); | ||
4803 | if (matchlen >= 0) { | ||
4804 | // check for target_id+1 immediately following, with same encoding & language | ||
4805 | if (i+1 < count && ttUSHORT(fc+loc+12+6) == next_id && ttUSHORT(fc+loc+12) == platform && ttUSHORT(fc+loc+12+2) == encoding && ttUSHORT(fc+loc+12+4) == language) { | ||
4806 | slen = ttUSHORT(fc+loc+12+8); | ||
4807 | off = ttUSHORT(fc+loc+12+10); | ||
4808 | if (slen == 0) { | ||
4809 | if (matchlen == nlen) | ||
4810 | return 1; | ||
4811 | } else if (matchlen < nlen && name[matchlen] == ' ') { | ||
4812 | ++matchlen; | ||
4813 | if (stbtt_CompareUTF8toUTF16_bigendian_internal((char*) (name+matchlen), nlen-matchlen, (char*)(fc+stringOffset+off),slen)) | ||
4814 | return 1; | ||
4815 | } | ||
4816 | } else { | ||
4817 | // if nothing immediately following | ||
4818 | if (matchlen == nlen) | ||
4819 | return 1; | ||
4820 | } | ||
4821 | } | ||
4822 | } | ||
4823 | |||
4824 | // @TODO handle other encodings | ||
4825 | } | ||
4826 | } | ||
4827 | return 0; | ||
4828 | } | ||
4829 | |||
4830 | static int stbtt__matches(stbtt_uint8 *fc, stbtt_uint32 offset, stbtt_uint8 *name, stbtt_int32 flags) | ||
4831 | { | ||
4832 | stbtt_int32 nlen = (stbtt_int32) STBTT_strlen((char *) name); | ||
4833 | stbtt_uint32 nm,hd; | ||
4834 | if (!stbtt__isfont(fc+offset)) return 0; | ||
4835 | |||
4836 | // check italics/bold/underline flags in macStyle... | ||
4837 | if (flags) { | ||
4838 | hd = stbtt__find_table(fc, offset, "head"); | ||
4839 | if ((ttUSHORT(fc+hd+44) & 7) != (flags & 7)) return 0; | ||
4840 | } | ||
4841 | |||
4842 | nm = stbtt__find_table(fc, offset, "name"); | ||
4843 | if (!nm) return 0; | ||
4844 | |||
4845 | if (flags) { | ||
4846 | // if we checked the macStyle flags, then just check the family and ignore the subfamily | ||
4847 | if (stbtt__matchpair(fc, nm, name, nlen, 16, -1)) return 1; | ||
4848 | if (stbtt__matchpair(fc, nm, name, nlen, 1, -1)) return 1; | ||
4849 | if (stbtt__matchpair(fc, nm, name, nlen, 3, -1)) return 1; | ||
4850 | } else { | ||
4851 | if (stbtt__matchpair(fc, nm, name, nlen, 16, 17)) return 1; | ||
4852 | if (stbtt__matchpair(fc, nm, name, nlen, 1, 2)) return 1; | ||
4853 | if (stbtt__matchpair(fc, nm, name, nlen, 3, -1)) return 1; | ||
4854 | } | ||
4855 | |||
4856 | return 0; | ||
4857 | } | ||
4858 | |||
4859 | static int stbtt_FindMatchingFont_internal(unsigned char *font_collection, char *name_utf8, stbtt_int32 flags) | ||
4860 | { | ||
4861 | stbtt_int32 i; | ||
4862 | for (i=0;;++i) { | ||
4863 | stbtt_int32 off = stbtt_GetFontOffsetForIndex(font_collection, i); | ||
4864 | if (off < 0) return off; | ||
4865 | if (stbtt__matches((stbtt_uint8 *) font_collection, off, (stbtt_uint8*) name_utf8, flags)) | ||
4866 | return off; | ||
4867 | } | ||
4868 | } | ||
4869 | |||
4870 | #if defined(__GNUC__) || defined(__clang__) | ||
4871 | #pragma GCC diagnostic push | ||
4872 | #pragma GCC diagnostic ignored "-Wcast-qual" | ||
4873 | #endif | ||
4874 | |||
4875 | STBTT_DEF int stbtt_BakeFontBitmap(const unsigned char *data, int offset, | ||
4876 | float pixel_height, unsigned char *pixels, int pw, int ph, | ||
4877 | int first_char, int num_chars, stbtt_bakedchar *chardata) | ||
4878 | { | ||
4879 | return stbtt_BakeFontBitmap_internal((unsigned char *) data, offset, pixel_height, pixels, pw, ph, first_char, num_chars, chardata); | ||
4880 | } | ||
4881 | |||
4882 | STBTT_DEF int stbtt_GetFontOffsetForIndex(const unsigned char *data, int index) | ||
4883 | { | ||
4884 | return stbtt_GetFontOffsetForIndex_internal((unsigned char *) data, index); | ||
4885 | } | ||
4886 | |||
4887 | STBTT_DEF int stbtt_GetNumberOfFonts(const unsigned char *data) | ||
4888 | { | ||
4889 | return stbtt_GetNumberOfFonts_internal((unsigned char *) data); | ||
4890 | } | ||
4891 | |||
4892 | STBTT_DEF int stbtt_InitFont(stbtt_fontinfo *info, const unsigned char *data, int offset) | ||
4893 | { | ||
4894 | return stbtt_InitFont_internal(info, (unsigned char *) data, offset); | ||
4895 | } | ||
4896 | |||
4897 | STBTT_DEF int stbtt_FindMatchingFont(const unsigned char *fontdata, const char *name, int flags) | ||
4898 | { | ||
4899 | return stbtt_FindMatchingFont_internal((unsigned char *) fontdata, (char *) name, flags); | ||
4900 | } | ||
4901 | |||
4902 | STBTT_DEF int stbtt_CompareUTF8toUTF16_bigendian(const char *s1, int len1, const char *s2, int len2) | ||
4903 | { | ||
4904 | return stbtt_CompareUTF8toUTF16_bigendian_internal((char *) s1, len1, (char *) s2, len2); | ||
4905 | } | ||
4906 | |||
4907 | #if defined(__GNUC__) || defined(__clang__) | ||
4908 | #pragma GCC diagnostic pop | ||
4909 | #endif | ||
4910 | |||
4911 | #endif // STB_TRUETYPE_IMPLEMENTATION | ||
4912 | |||
4913 | |||
4914 | // FULL VERSION HISTORY | ||
4915 | // | ||
4916 | // 1.19 (2018-02-11) OpenType GPOS kerning (horizontal only), STBTT_fmod | ||
4917 | // 1.18 (2018-01-29) add missing function | ||
4918 | // 1.17 (2017-07-23) make more arguments const; doc fix | ||
4919 | // 1.16 (2017-07-12) SDF support | ||
4920 | // 1.15 (2017-03-03) make more arguments const | ||
4921 | // 1.14 (2017-01-16) num-fonts-in-TTC function | ||
4922 | // 1.13 (2017-01-02) support OpenType fonts, certain Apple fonts | ||
4923 | // 1.12 (2016-10-25) suppress warnings about casting away const with -Wcast-qual | ||
4924 | // 1.11 (2016-04-02) fix unused-variable warning | ||
4925 | // 1.10 (2016-04-02) allow user-defined fabs() replacement | ||
4926 | // fix memory leak if fontsize=0.0 | ||
4927 | // fix warning from duplicate typedef | ||
4928 | // 1.09 (2016-01-16) warning fix; avoid crash on outofmem; use alloc userdata for PackFontRanges | ||
4929 | // 1.08 (2015-09-13) document stbtt_Rasterize(); fixes for vertical & horizontal edges | ||
4930 | // 1.07 (2015-08-01) allow PackFontRanges to accept arrays of sparse codepoints; | ||
4931 | // allow PackFontRanges to pack and render in separate phases; | ||
4932 | // fix stbtt_GetFontOFfsetForIndex (never worked for non-0 input?); | ||
4933 | // fixed an assert() bug in the new rasterizer | ||
4934 | // replace assert() with STBTT_assert() in new rasterizer | ||
4935 | // 1.06 (2015-07-14) performance improvements (~35% faster on x86 and x64 on test machine) | ||
4936 | // also more precise AA rasterizer, except if shapes overlap | ||
4937 | // remove need for STBTT_sort | ||
4938 | // 1.05 (2015-04-15) fix misplaced definitions for STBTT_STATIC | ||
4939 | // 1.04 (2015-04-15) typo in example | ||
4940 | // 1.03 (2015-04-12) STBTT_STATIC, fix memory leak in new packing, various fixes | ||
4941 | // 1.02 (2014-12-10) fix various warnings & compile issues w/ stb_rect_pack, C++ | ||
4942 | // 1.01 (2014-12-08) fix subpixel position when oversampling to exactly match | ||
4943 | // non-oversampled; STBTT_POINT_SIZE for packed case only | ||
4944 | // 1.00 (2014-12-06) add new PackBegin etc. API, w/ support for oversampling | ||
4945 | // 0.99 (2014-09-18) fix multiple bugs with subpixel rendering (ryg) | ||
4946 | // 0.9 (2014-08-07) support certain mac/iOS fonts without an MS platformID | ||
4947 | // 0.8b (2014-07-07) fix a warning | ||
4948 | // 0.8 (2014-05-25) fix a few more warnings | ||
4949 | // 0.7 (2013-09-25) bugfix: subpixel glyph bug fixed in 0.5 had come back | ||
4950 | // 0.6c (2012-07-24) improve documentation | ||
4951 | // 0.6b (2012-07-20) fix a few more warnings | ||
4952 | // 0.6 (2012-07-17) fix warnings; added stbtt_ScaleForMappingEmToPixels, | ||
4953 | // stbtt_GetFontBoundingBox, stbtt_IsGlyphEmpty | ||
4954 | // 0.5 (2011-12-09) bugfixes: | ||
4955 | // subpixel glyph renderer computed wrong bounding box | ||
4956 | // first vertex of shape can be off-curve (FreeSans) | ||
4957 | // 0.4b (2011-12-03) fixed an error in the font baking example | ||
4958 | // 0.4 (2011-12-01) kerning, subpixel rendering (tor) | ||
4959 | // bugfixes for: | ||
4960 | // codepoint-to-glyph conversion using table fmt=12 | ||
4961 | // codepoint-to-glyph conversion using table fmt=4 | ||
4962 | // stbtt_GetBakedQuad with non-square texture (Zer) | ||
4963 | // updated Hello World! sample to use kerning and subpixel | ||
4964 | // fixed some warnings | ||
4965 | // 0.3 (2009-06-24) cmap fmt=12, compound shapes (MM) | ||
4966 | // userdata, malloc-from-userdata, non-zero fill (stb) | ||
4967 | // 0.2 (2009-03-11) Fix unsigned/signed char warnings | ||
4968 | // 0.1 (2009-03-09) First public release | ||
4969 | // | ||
4970 | |||
4971 | /* | ||
4972 | ------------------------------------------------------------------------------ | ||
4973 | This software is available under 2 licenses -- choose whichever you prefer. | ||
4974 | ------------------------------------------------------------------------------ | ||
4975 | ALTERNATIVE A - MIT License | ||
4976 | Copyright (c) 2017 Sean Barrett | ||
4977 | Permission is hereby granted, free of charge, to any person obtaining a copy of | ||
4978 | this software and associated documentation files (the "Software"), to deal in | ||
4979 | the Software without restriction, including without limitation the rights to | ||
4980 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies | ||
4981 | of the Software, and to permit persons to whom the Software is furnished to do | ||
4982 | so, subject to the following conditions: | ||
4983 | The above copyright notice and this permission notice shall be included in all | ||
4984 | copies or substantial portions of the Software. | ||
4985 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
4986 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
4987 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | ||
4988 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | ||
4989 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | ||
4990 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | ||
4991 | SOFTWARE. | ||
4992 | ------------------------------------------------------------------------------ | ||
4993 | ALTERNATIVE B - Public Domain (www.unlicense.org) | ||
4994 | This is free and unencumbered software released into the public domain. | ||
4995 | Anyone is free to copy, modify, publish, use, compile, sell, or distribute this | ||
4996 | software, either in source code form or as a compiled binary, for any purpose, | ||
4997 | commercial or non-commercial, and by any means. | ||
4998 | In jurisdictions that recognize copyright laws, the author or authors of this | ||
4999 | software dedicate any and all copyright interest in the software to the public | ||
5000 | domain. We make this dedication for the benefit of the public at large and to | ||
5001 | the detriment of our heirs and successors. We intend this dedication to be an | ||
5002 | overt act of relinquishment in perpetuity of all present and future rights to | ||
5003 | this software under copyright law. | ||
5004 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
5005 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
5006 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | ||
5007 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | ||
5008 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | ||
5009 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | ||
5010 | ------------------------------------------------------------------------------ | ||
5011 | */ | ||
diff --git a/src/ui/color.c b/src/ui/color.c new file mode 100644 index 00000000..365bf986 --- /dev/null +++ b/src/ui/color.c | |||
@@ -0,0 +1,27 @@ | |||
1 | #include "color.h" | ||
2 | |||
3 | static const iColor transparent_; | ||
4 | |||
5 | iColor get_Color(int color) { | ||
6 | static const iColor palette[] = { | ||
7 | { 0, 0, 0, 255 }, | ||
8 | { 40, 40, 40, 255 }, | ||
9 | { 80, 80, 80, 255 }, | ||
10 | { 160, 160, 160, 255 }, | ||
11 | { 255, 255, 255, 255 }, | ||
12 | { 106, 80, 0, 255 }, | ||
13 | { 255, 192, 0, 255 }, | ||
14 | { 0, 96, 128, 255 }, | ||
15 | { 0, 192, 255, 255 }, | ||
16 | { 255, 255, 32, 255 }, | ||
17 | { 255, 64, 64, 255 }, | ||
18 | { 255, 0, 255, 255 }, | ||
19 | { 132, 132, 255, 255 }, | ||
20 | { 0, 200, 0, 255 }, | ||
21 | }; | ||
22 | const iColor *clr = &transparent_; | ||
23 | if (color >= 0 && color < (int) iElemCount(palette)) { | ||
24 | clr = &palette[color]; | ||
25 | } | ||
26 | return *clr; | ||
27 | } | ||
diff --git a/src/ui/color.h b/src/ui/color.h new file mode 100644 index 00000000..f0244fc2 --- /dev/null +++ b/src/ui/color.h | |||
@@ -0,0 +1,48 @@ | |||
1 | #pragma once | ||
2 | |||
3 | #include <the_Foundation/defs.h> | ||
4 | |||
5 | enum iColorId { | ||
6 | none_ColorId = -1, | ||
7 | black_ColorId, | ||
8 | gray25_ColorId, | ||
9 | gray50_ColorId, | ||
10 | gray75_ColorId, | ||
11 | white_ColorId, | ||
12 | brown_ColorId, | ||
13 | orange_ColorId, | ||
14 | teal_ColorId, | ||
15 | cyan_ColorId, | ||
16 | yellow_ColorId, | ||
17 | red_ColorId, | ||
18 | magenta_ColorId, | ||
19 | blue_ColorId, | ||
20 | green_ColorId, | ||
21 | max_ColorId | ||
22 | }; | ||
23 | |||
24 | #define mask_ColorId 0x0f | ||
25 | #define permanent_ColorId 0x80 /* cannot be changed via escapes */ | ||
26 | |||
27 | #define black_ColorEscape "\r0" | ||
28 | #define gray25_ColorEscape "\r1" | ||
29 | #define gray50_ColorEscape "\r2" | ||
30 | #define gray75_ColorEscape "\r3" | ||
31 | #define white_ColorEscape "\r4" | ||
32 | #define brown_ColorEscape "\r5" | ||
33 | #define orange_ColorEscape "\r6" | ||
34 | #define teal_ColorEscape "\r7" | ||
35 | #define cyan_ColorEscape "\r8" | ||
36 | #define yellow_ColorEscape "\r9" | ||
37 | #define red_ColorEscape "\r:" | ||
38 | #define magenta_ColorEscape "\r;" | ||
39 | #define blue_ColorEscape "\r<" | ||
40 | #define green_ColorEscape "\r=" | ||
41 | |||
42 | iDeclareType(Color) | ||
43 | |||
44 | struct Impl_Color { | ||
45 | uint8_t r, g, b, a; | ||
46 | }; | ||
47 | |||
48 | iColor get_Color (int color); | ||
diff --git a/src/ui/command.c b/src/ui/command.c new file mode 100644 index 00000000..16a0d948 --- /dev/null +++ b/src/ui/command.c | |||
@@ -0,0 +1,89 @@ | |||
1 | #include "command.h" | ||
2 | #include "app.h" | ||
3 | |||
4 | #include <the_Foundation/string.h> | ||
5 | #include <ctype.h> | ||
6 | |||
7 | iBool equal_Command(const char *cmdWithArgs, const char *cmd) { | ||
8 | if (strchr(cmdWithArgs, ':')) { | ||
9 | return beginsWith_CStr(cmdWithArgs, cmd) && cmdWithArgs[strlen(cmd)] == ' '; | ||
10 | } | ||
11 | return equal_CStr(cmdWithArgs, cmd); | ||
12 | } | ||
13 | |||
14 | static const iString *tokenString_(const char *label) { | ||
15 | return collectNewFormat_String(" %s:", label); | ||
16 | } | ||
17 | |||
18 | int argLabel_Command(const char *cmd, const char *label) { | ||
19 | const iString *tok = tokenString_(label); | ||
20 | const char *ptr = strstr(cmd, cstr_String(tok)); | ||
21 | if (ptr) { | ||
22 | return atoi(ptr + size_String(tok)); | ||
23 | } | ||
24 | return 0; | ||
25 | } | ||
26 | |||
27 | int arg_Command(const char *cmd) { | ||
28 | return argLabel_Command(cmd, "arg"); | ||
29 | } | ||
30 | |||
31 | float argf_Command(const char *cmd) { | ||
32 | const char *ptr = strstr(cmd, " arg:"); | ||
33 | if (ptr) { | ||
34 | return strtof(ptr + 5, NULL); | ||
35 | } | ||
36 | return 0; | ||
37 | } | ||
38 | |||
39 | void *pointerLabel_Command(const char *cmd, const char *label) { | ||
40 | const iString *tok = tokenString_(label); | ||
41 | const char *ptr = strstr(cmd, cstr_String(tok)); | ||
42 | if (ptr) { | ||
43 | void *val = NULL; | ||
44 | sscanf(ptr + size_String(tok), "%p", &val); | ||
45 | return val; | ||
46 | } | ||
47 | return NULL; | ||
48 | } | ||
49 | |||
50 | void *pointer_Command(const char *cmd) { | ||
51 | return pointerLabel_Command(cmd, "ptr"); | ||
52 | } | ||
53 | |||
54 | const char *valuePtr_Command(const char *cmd, const char *label) { | ||
55 | const iString *tok = tokenString_(label); | ||
56 | const char *ptr = strstr(cmd, cstr_String(tok)); | ||
57 | if (ptr) { | ||
58 | return ptr + size_String(tok); | ||
59 | } | ||
60 | return NULL; | ||
61 | } | ||
62 | |||
63 | const iString *string_Command(const char *cmd, const char *label) { | ||
64 | iRangecc val = { valuePtr_Command(cmd, label), NULL }; | ||
65 | if (val.start) { | ||
66 | for (val.end = val.start; *val.end && !isspace(*val.end); val.end++) {} | ||
67 | return collect_String(newRange_String(&val)); | ||
68 | } | ||
69 | return collectNew_String(); | ||
70 | } | ||
71 | |||
72 | iInt2 dir_Command(const char *cmd) { | ||
73 | const char *ptr = strstr(cmd, " dir:"); | ||
74 | if (ptr) { | ||
75 | iInt2 dir; | ||
76 | sscanf(ptr + 5, "%d%d", &dir.x, &dir.y); | ||
77 | return dir; | ||
78 | } | ||
79 | return zero_I2(); | ||
80 | } | ||
81 | |||
82 | iInt2 coord_Command(const char *cmd) { | ||
83 | iInt2 coord = zero_I2(); | ||
84 | const char *ptr = strstr(cmd, " coord:"); | ||
85 | if (ptr) { | ||
86 | sscanf(ptr + 7, "%d%d", &coord.x, &coord.y); | ||
87 | } | ||
88 | return coord; | ||
89 | } | ||
diff --git a/src/ui/command.h b/src/ui/command.h new file mode 100644 index 00000000..84533d77 --- /dev/null +++ b/src/ui/command.h | |||
@@ -0,0 +1,16 @@ | |||
1 | #pragma once | ||
2 | |||
3 | #include <the_Foundation/vec2.h> | ||
4 | |||
5 | iBool equal_Command (const char *commandWithArgs, const char *command); | ||
6 | |||
7 | int arg_Command (const char *); /* arg: */ | ||
8 | float argf_Command (const char *); /* arg: */ | ||
9 | int argLabel_Command (const char *, const char *label); | ||
10 | void * pointer_Command (const char *); /* ptr: */ | ||
11 | void * pointerLabel_Command (const char *, const char *label); | ||
12 | iInt2 coord_Command (const char *); | ||
13 | iInt2 dir_Command (const char *); | ||
14 | |||
15 | const iString * string_Command (const char *, const char *label); | ||
16 | const char * valuePtr_Command(const char *, const char *label); | ||
diff --git a/src/ui/inputwidget.c b/src/ui/inputwidget.c new file mode 100644 index 00000000..7a2b7d1c --- /dev/null +++ b/src/ui/inputwidget.c | |||
@@ -0,0 +1,280 @@ | |||
1 | #include "inputwidget.h" | ||
2 | #include "paint.h" | ||
3 | #include "util.h" | ||
4 | |||
5 | #include <the_Foundation/array.h> | ||
6 | #include <SDL_timer.h> | ||
7 | |||
8 | struct Impl_InputWidget { | ||
9 | iWidget widget; | ||
10 | enum iInputMode mode; | ||
11 | size_t maxLen; | ||
12 | iArray text; /* iChar[] */ | ||
13 | iArray oldText; /* iChar[] */ | ||
14 | size_t cursor; | ||
15 | int font; | ||
16 | iClick click; | ||
17 | }; | ||
18 | |||
19 | iDefineObjectConstructionArgs(InputWidget, (size_t maxLen), maxLen) | ||
20 | |||
21 | void init_InputWidget(iInputWidget *d, size_t maxLen) { | ||
22 | iWidget *w = &d->widget; | ||
23 | init_Widget(w); | ||
24 | setFlags_Widget(w, focusable_WidgetFlag | hover_WidgetFlag, iTrue); | ||
25 | init_Array(&d->text, sizeof(iChar)); | ||
26 | init_Array(&d->oldText, sizeof(iChar)); | ||
27 | d->font = uiInput_FontId; | ||
28 | d->cursor = 0; | ||
29 | setMaxLen_InputWidget(d, maxLen); | ||
30 | if (maxLen == 0) { | ||
31 | /* Caller must arrange the width. */ | ||
32 | w->rect.size.y = lineHeight_Text(d->font) + 2 * gap_UI; | ||
33 | setFlags_Widget(w, fixedHeight_WidgetFlag, iTrue); | ||
34 | } | ||
35 | init_Click(&d->click, d, SDL_BUTTON_LEFT); | ||
36 | } | ||
37 | |||
38 | void deinit_InputWidget(iInputWidget *d) { | ||
39 | deinit_Array(&d->oldText); | ||
40 | deinit_Array(&d->text); | ||
41 | } | ||
42 | |||
43 | void setMode_InputWidget(iInputWidget *d, enum iInputMode mode) { | ||
44 | d->mode = mode; | ||
45 | } | ||
46 | |||
47 | const iString *text_InputWidget(const iInputWidget *d) { | ||
48 | return collect_String(newUnicodeN_String(constData_Array(&d->text), size_Array(&d->text))); | ||
49 | } | ||
50 | |||
51 | void setMaxLen_InputWidget(iInputWidget *d, size_t maxLen) { | ||
52 | d->maxLen = maxLen; | ||
53 | d->mode = (maxLen == 0 ? insert_InputMode : overwrite_InputMode); | ||
54 | resize_Array(&d->text, maxLen); | ||
55 | if (maxLen) { | ||
56 | /* Set a fixed size. */ | ||
57 | iBlock *content = new_Block(maxLen); | ||
58 | fill_Block(content, 'M'); | ||
59 | setSize_Widget( | ||
60 | as_Widget(d), | ||
61 | add_I2(measure_Text(d->font, cstr_Block(content)), init_I2(6 * gap_UI, 2 * gap_UI))); | ||
62 | delete_Block(content); | ||
63 | } | ||
64 | } | ||
65 | |||
66 | void setText_InputWidget(iInputWidget *d, const iString *text) { | ||
67 | clear_Array(&d->text); | ||
68 | iConstForEach(String, i, text) { | ||
69 | pushBack_Array(&d->text, &i.value); | ||
70 | } | ||
71 | } | ||
72 | |||
73 | void setCursor_InputWidget(iInputWidget *d, size_t pos) { | ||
74 | d->cursor = iMin(pos, size_Array(&d->text)); | ||
75 | } | ||
76 | |||
77 | void begin_InputWidget(iInputWidget *d) { | ||
78 | iWidget *w = as_Widget(d); | ||
79 | if (flags_Widget(w) & selected_WidgetFlag) { | ||
80 | /* Already active. */ | ||
81 | return; | ||
82 | } | ||
83 | setFlags_Widget(w, hidden_WidgetFlag | disabled_WidgetFlag, iFalse); | ||
84 | setCopy_Array(&d->oldText, &d->text); | ||
85 | if (d->mode == overwrite_InputMode) { | ||
86 | d->cursor = 0; | ||
87 | } | ||
88 | else { | ||
89 | d->cursor = iMin(size_Array(&d->text), d->maxLen - 1); | ||
90 | } | ||
91 | SDL_StartTextInput(); | ||
92 | setFlags_Widget(w, selected_WidgetFlag, iTrue); | ||
93 | } | ||
94 | |||
95 | void end_InputWidget(iInputWidget *d, iBool accept) { | ||
96 | iWidget *w = as_Widget(d); | ||
97 | if (~flags_Widget(w) & selected_WidgetFlag) { | ||
98 | /* Was not active. */ | ||
99 | return; | ||
100 | } | ||
101 | if (!accept) { | ||
102 | setCopy_Array(&d->text, &d->oldText); | ||
103 | } | ||
104 | SDL_StopTextInput(); | ||
105 | setFlags_Widget(w, selected_WidgetFlag, iFalse); | ||
106 | const char *id = cstr_String(id_Widget(as_Widget(d))); | ||
107 | if (!*id) id = "_"; | ||
108 | postCommand_Widget(w, "input.ended id:%s arg:%d", id, accept ? 1 : 0); | ||
109 | } | ||
110 | |||
111 | static iBool processEvent_InputWidget_(iInputWidget *d, const SDL_Event *ev) { | ||
112 | if (isCommand_Widget(as_Widget(d), ev, "focus.gained")) { | ||
113 | begin_InputWidget(d); | ||
114 | return iTrue; | ||
115 | } | ||
116 | else if (isCommand_Widget(as_Widget(d), ev, "focus.lost")) { | ||
117 | end_InputWidget(d, iTrue); | ||
118 | return iTrue; | ||
119 | } | ||
120 | switch (processEvent_Click(&d->click, ev)) { | ||
121 | case none_ClickResult: | ||
122 | break; | ||
123 | case started_ClickResult: | ||
124 | case drag_ClickResult: | ||
125 | case double_ClickResult: | ||
126 | case aborted_ClickResult: | ||
127 | return iTrue; | ||
128 | case finished_ClickResult: | ||
129 | setFocus_Widget(as_Widget(d)); | ||
130 | return iTrue; | ||
131 | } | ||
132 | if (ev->type == SDL_KEYUP) { | ||
133 | return iTrue; | ||
134 | } | ||
135 | const size_t curMax = iMin(size_Array(&d->text), d->maxLen - 1); | ||
136 | if (ev->type == SDL_KEYDOWN && isFocused_Widget(as_Widget(d))) { | ||
137 | const int key = ev->key.keysym.sym; | ||
138 | const int mods = keyMods_Sym(ev->key.keysym.mod); | ||
139 | switch (key) { | ||
140 | case SDLK_RETURN: | ||
141 | case SDLK_KP_ENTER: | ||
142 | setFocus_Widget(NULL); | ||
143 | return iTrue; | ||
144 | case SDLK_ESCAPE: | ||
145 | end_InputWidget(d, iFalse); | ||
146 | setFocus_Widget(NULL); | ||
147 | return iTrue; | ||
148 | case SDLK_BACKSPACE: | ||
149 | if (mods & KMOD_ALT) { | ||
150 | clear_Array(&d->text); | ||
151 | d->cursor = 0; | ||
152 | } | ||
153 | else if (d->cursor > 0) { | ||
154 | remove_Array(&d->text, --d->cursor); | ||
155 | } | ||
156 | return iTrue; | ||
157 | case SDLK_d: | ||
158 | if (mods != KMOD_CTRL) break; | ||
159 | case SDLK_DELETE: | ||
160 | if (d->cursor < size_Array(&d->text)) { | ||
161 | remove_Array(&d->text, d->cursor); | ||
162 | } | ||
163 | return iTrue; | ||
164 | case SDLK_k: | ||
165 | if (mods == KMOD_CTRL) { | ||
166 | removeN_Array(&d->text, d->cursor, size_Array(&d->text) - d->cursor); | ||
167 | return iTrue; | ||
168 | } | ||
169 | break; | ||
170 | case SDLK_HOME: | ||
171 | case SDLK_END: | ||
172 | d->cursor = (key == SDLK_HOME ? 0 : curMax); | ||
173 | return iTrue; | ||
174 | case SDLK_a: | ||
175 | case SDLK_e: | ||
176 | if (mods == KMOD_CTRL) { | ||
177 | d->cursor = (key == 'a' ? 0 : curMax); | ||
178 | return iTrue; | ||
179 | } | ||
180 | break; | ||
181 | case SDLK_LEFT: | ||
182 | if (mods & KMOD_PRIMARY) { | ||
183 | d->cursor = 0; | ||
184 | } | ||
185 | else if (d->cursor > 0) { | ||
186 | d->cursor--; | ||
187 | } | ||
188 | return iTrue; | ||
189 | case SDLK_RIGHT: | ||
190 | if (mods & KMOD_PRIMARY) { | ||
191 | d->cursor = curMax; | ||
192 | } | ||
193 | else if (d->cursor < curMax) { | ||
194 | d->cursor++; | ||
195 | } | ||
196 | return iTrue; | ||
197 | case SDLK_TAB: | ||
198 | /* Allow focus switching. */ | ||
199 | return processEvent_Widget(as_Widget(d), ev); | ||
200 | } | ||
201 | if (mods & (KMOD_PRIMARY | KMOD_SECONDARY)) { | ||
202 | return iFalse; | ||
203 | } | ||
204 | return iTrue; | ||
205 | } | ||
206 | else if (ev->type == SDL_TEXTINPUT && isFocused_Widget(as_Widget(d))) { | ||
207 | const iString *uni = collectNewCStr_String(ev->text.text); | ||
208 | const iChar chr = first_String(uni); | ||
209 | if (d->mode == insert_InputMode) { | ||
210 | insert_Array(&d->text, d->cursor, &chr); | ||
211 | d->cursor++; | ||
212 | } | ||
213 | else { | ||
214 | if (d->cursor >= size_Array(&d->text)) { | ||
215 | resize_Array(&d->text, d->cursor + 1); | ||
216 | } | ||
217 | set_Array(&d->text, d->cursor++, &chr); | ||
218 | if (d->maxLen && d->cursor == d->maxLen) { | ||
219 | setFocus_Widget(NULL); | ||
220 | } | ||
221 | } | ||
222 | return iTrue; | ||
223 | } | ||
224 | return processEvent_Widget(as_Widget(d), ev); | ||
225 | } | ||
226 | |||
227 | static void draw_InputWidget_(const iInputWidget *d) { | ||
228 | const uint32_t time = frameTime_Window(get_Window()); | ||
229 | const iInt2 padding = init_I2(3 * gap_UI, gap_UI); | ||
230 | iRect bounds = adjusted_Rect(bounds_Widget(constAs_Widget(d)), padding, neg_I2(padding)); | ||
231 | const iBool isFocused = isFocused_Widget(constAs_Widget(d)); | ||
232 | const iBool isHover = isHover_Widget(constAs_Widget(d)) && | ||
233 | contains_Widget(constAs_Widget(d), mouseCoord_Window(get_Window())); | ||
234 | iPaint p; | ||
235 | init_Paint(&p); | ||
236 | iString text; | ||
237 | initUnicodeN_String(&text, constData_Array(&d->text), size_Array(&d->text)); | ||
238 | fillRect_Paint(&p, bounds, black_ColorId); | ||
239 | drawRect_Paint(&p, | ||
240 | adjusted_Rect(bounds, neg_I2(one_I2()), zero_I2()), | ||
241 | isFocused ? orange_ColorId : isHover ? cyan_ColorId : gray50_ColorId); | ||
242 | setClip_Paint(&p, bounds); | ||
243 | const iInt2 emSize = advance_Text(d->font, "M"); | ||
244 | const int textWidth = advance_Text(d->font, cstr_String(&text)).x; | ||
245 | const int cursorX = advanceN_Text(d->font, cstr_String(&text), d->cursor).x; | ||
246 | int xOff = 0; | ||
247 | if (d->maxLen == 0) { | ||
248 | if (textWidth > width_Rect(bounds) - emSize.x) { | ||
249 | xOff = width_Rect(bounds) - emSize.x - textWidth; | ||
250 | } | ||
251 | if (cursorX + xOff < width_Rect(bounds) / 2) { | ||
252 | xOff = width_Rect(bounds) / 2 - cursorX; | ||
253 | } | ||
254 | xOff = iMin(xOff, 0); | ||
255 | } | ||
256 | draw_Text(d->font, addX_I2(topLeft_Rect(bounds), xOff), white_ColorId, cstr_String(&text)); | ||
257 | clearClip_Paint(&p); | ||
258 | /* Cursor blinking. */ | ||
259 | if (isFocused && (time & 256)) { | ||
260 | const iInt2 prefixSize = advanceN_Text(d->font, cstr_String(&text), d->cursor); | ||
261 | const iInt2 curPos = init_I2(xOff + left_Rect(bounds) + prefixSize.x, top_Rect(bounds)); | ||
262 | const iRect curRect = { curPos, addX_I2(emSize, 1) }; | ||
263 | iString cur; | ||
264 | if (d->cursor < size_Array(&d->text)) { | ||
265 | initUnicodeN_String(&cur, constAt_Array(&d->text, d->cursor), 1); | ||
266 | } | ||
267 | else { | ||
268 | initCStr_String(&cur, " "); | ||
269 | } | ||
270 | fillRect_Paint(&p, curRect, orange_ColorId); | ||
271 | draw_Text(d->font, curPos, black_ColorId, cstr_String(&cur)); | ||
272 | deinit_String(&cur); | ||
273 | } | ||
274 | deinit_String(&text); | ||
275 | } | ||
276 | |||
277 | iBeginDefineSubclass(InputWidget, Widget) | ||
278 | .processEvent = (iAny *) processEvent_InputWidget_, | ||
279 | .draw = (iAny *) draw_InputWidget_, | ||
280 | iEndDefineSubclass(InputWidget) | ||
diff --git a/src/ui/inputwidget.h b/src/ui/inputwidget.h new file mode 100644 index 00000000..b606f974 --- /dev/null +++ b/src/ui/inputwidget.h | |||
@@ -0,0 +1,20 @@ | |||
1 | #pragma once | ||
2 | |||
3 | #include "widget.h" | ||
4 | |||
5 | iDeclareWidgetClass(InputWidget) | ||
6 | iDeclareObjectConstructionArgs(InputWidget, size_t maxLen) | ||
7 | |||
8 | enum iInputMode { | ||
9 | insert_InputMode, | ||
10 | overwrite_InputMode, | ||
11 | }; | ||
12 | |||
13 | void setMode_InputWidget (iInputWidget *, enum iInputMode mode); | ||
14 | void setMaxLen_InputWidget (iInputWidget *, size_t maxLen); | ||
15 | void setText_InputWidget (iInputWidget *, const iString *text); | ||
16 | void setCursor_InputWidget (iInputWidget *, size_t pos); | ||
17 | void begin_InputWidget (iInputWidget *); | ||
18 | void end_InputWidget (iInputWidget *, iBool accept); | ||
19 | |||
20 | const iString * text_InputWidget (const iInputWidget *); | ||
diff --git a/src/ui/labelwidget.c b/src/ui/labelwidget.c new file mode 100644 index 00000000..7b64857b --- /dev/null +++ b/src/ui/labelwidget.c | |||
@@ -0,0 +1,281 @@ | |||
1 | #include "labelwidget.h" | ||
2 | #include "text.h" | ||
3 | #include "color.h" | ||
4 | #include "paint.h" | ||
5 | #include "app.h" | ||
6 | #include "util.h" | ||
7 | |||
8 | iLocalDef iInt2 padding_(void) { return init_I2(3 * gap_UI, gap_UI); } | ||
9 | |||
10 | struct Impl_LabelWidget { | ||
11 | iWidget widget; | ||
12 | iString label; | ||
13 | int font; | ||
14 | int key; | ||
15 | int kmods; | ||
16 | iString command; | ||
17 | iClick click; | ||
18 | }; | ||
19 | |||
20 | iDefineObjectConstructionArgs(LabelWidget, | ||
21 | (const char *label, int key, int kmods, const char *cmd), | ||
22 | label, key, kmods, cmd) | ||
23 | |||
24 | static iBool checkModifiers_(int have, int req) { | ||
25 | return keyMods_Sym(req) == keyMods_Sym(have); | ||
26 | } | ||
27 | |||
28 | static void trigger_LabelWidget_(const iLabelWidget *d) { | ||
29 | postCommand_Widget(&d->widget, "%s", cstr_String(&d->command)); | ||
30 | } | ||
31 | |||
32 | static iBool processEvent_LabelWidget_(iLabelWidget *d, const SDL_Event *ev) { | ||
33 | if (isCommand_UserEvent(ev, "metrics.changed")) { | ||
34 | updateSize_LabelWidget(d); | ||
35 | } | ||
36 | if (!isEmpty_String(&d->command)) { | ||
37 | switch (processEvent_Click(&d->click, ev)) { | ||
38 | case started_ClickResult: | ||
39 | setFlags_Widget(&d->widget, pressed_WidgetFlag, iTrue); | ||
40 | return iTrue; | ||
41 | case aborted_ClickResult: | ||
42 | setFlags_Widget(&d->widget, pressed_WidgetFlag, iFalse); | ||
43 | return iTrue; | ||
44 | case finished_ClickResult: | ||
45 | setFlags_Widget(&d->widget, pressed_WidgetFlag, iFalse); | ||
46 | trigger_LabelWidget_(d); | ||
47 | return iTrue; | ||
48 | case double_ClickResult: | ||
49 | return iTrue; | ||
50 | default: | ||
51 | break; | ||
52 | } | ||
53 | switch (ev->type) { | ||
54 | case SDL_KEYDOWN: { | ||
55 | const int mods = ev->key.keysym.mod; | ||
56 | if (d->key && ev->key.keysym.sym == d->key && checkModifiers_(mods, d->kmods)) { | ||
57 | trigger_LabelWidget_(d); | ||
58 | return iTrue; | ||
59 | } | ||
60 | break; | ||
61 | } | ||
62 | } | ||
63 | } | ||
64 | return processEvent_Widget(&d->widget, ev); | ||
65 | } | ||
66 | |||
67 | static void keyStr_LabelWidget_(const iLabelWidget *d, iString *str) { | ||
68 | #if defined (iPlatformApple) | ||
69 | if (d->kmods & KMOD_CTRL) { | ||
70 | appendChar_String(str, 0x2303); | ||
71 | } | ||
72 | if (d->kmods & KMOD_ALT) { | ||
73 | appendChar_String(str, 0x2325); | ||
74 | } | ||
75 | if (d->kmods & KMOD_SHIFT) { | ||
76 | appendChar_String(str, 0x21e7); | ||
77 | } | ||
78 | if (d->kmods & KMOD_GUI) { | ||
79 | appendChar_String(str, 0x2318); | ||
80 | } | ||
81 | #else | ||
82 | if (d->kmods & KMOD_CTRL) { | ||
83 | appendCStr_String(str, "Ctrl+"); | ||
84 | } | ||
85 | if (d->kmods & KMOD_ALT) { | ||
86 | appendCStr_String(str, "Alt+"); | ||
87 | } | ||
88 | if (d->kmods & KMOD_SHIFT) { | ||
89 | appendCStr_String(str, "Shift+"); | ||
90 | } | ||
91 | if (d->kmods & KMOD_GUI) { | ||
92 | appendCStr_String(str, "Meta+"); | ||
93 | } | ||
94 | #endif | ||
95 | if (d->key == 0x20) { | ||
96 | appendCStr_String(str, "Space"); | ||
97 | } | ||
98 | else if (d->key == SDLK_LEFT) { | ||
99 | appendChar_String(str, 0x2190); | ||
100 | } | ||
101 | else if (d->key == SDLK_RIGHT) { | ||
102 | appendChar_String(str, 0x2192); | ||
103 | } | ||
104 | else if (d->key < 128 && (isalnum(d->key) || ispunct(d->key))) { | ||
105 | appendChar_String(str, upper_Char(d->key)); | ||
106 | } | ||
107 | else if (d->key == SDLK_BACKSPACE) { | ||
108 | appendChar_String(str, 0x232b); /* Erase to the Left */ | ||
109 | } | ||
110 | else if (d->key == SDLK_DELETE) { | ||
111 | appendChar_String(str, 0x2326); /* Erase to the Right */ | ||
112 | } | ||
113 | else { | ||
114 | appendCStr_String(str, SDL_GetKeyName(d->key)); | ||
115 | } | ||
116 | } | ||
117 | |||
118 | static void draw_LabelWidget_(const iLabelWidget *d) { | ||
119 | const iWidget *w = constAs_Widget(d); | ||
120 | draw_Widget(w); | ||
121 | const iBool isButton = d->click.button != 0; | ||
122 | const int flags = flags_Widget(w); | ||
123 | const iRect bounds = bounds_Widget(w); | ||
124 | iRect rect = bounds; | ||
125 | if (isButton) { | ||
126 | shrink_Rect(&rect, divi_I2(gap2_UI, 4)); | ||
127 | adjustEdges_Rect(&rect, gap_UI / 8, 0, -gap_UI / 8, 0); | ||
128 | } | ||
129 | iPaint p; | ||
130 | init_Paint(&p); | ||
131 | int bg = 0; | ||
132 | int fg = gray75_ColorId; | ||
133 | int frame = isButton ? gray50_ColorId : gray25_ColorId; | ||
134 | int frame2 = isButton ? black_ColorId : frame; | ||
135 | if (flags & selected_WidgetFlag) { | ||
136 | bg = teal_ColorId; | ||
137 | fg = white_ColorId; | ||
138 | frame = isButton ? cyan_ColorId : frame; | ||
139 | } | ||
140 | if (isHover_Widget(w)) { | ||
141 | if (flags & frameless_WidgetFlag) { | ||
142 | bg = teal_ColorId; | ||
143 | fg = white_ColorId; | ||
144 | if (isButton && flags & selected_WidgetFlag) frame = white_ColorId; | ||
145 | } | ||
146 | else { | ||
147 | if (frame != cyan_ColorId) { | ||
148 | if (startsWith_String(&d->label, orange_ColorEscape)) { | ||
149 | frame = orange_ColorId; | ||
150 | frame2 = brown_ColorId; | ||
151 | } | ||
152 | else { | ||
153 | frame = cyan_ColorId; | ||
154 | frame2 = teal_ColorId; | ||
155 | } | ||
156 | } | ||
157 | else { | ||
158 | frame = white_ColorId; | ||
159 | frame2 = cyan_ColorId; | ||
160 | } | ||
161 | } | ||
162 | } | ||
163 | if (flags & pressed_WidgetFlag) { | ||
164 | bg = orange_ColorId | permanent_ColorId; | ||
165 | if (isButton) frame = bg; | ||
166 | fg = black_ColorId | permanent_ColorId; | ||
167 | } | ||
168 | if (bg) { | ||
169 | fillRect_Paint(&p, rect, bg); | ||
170 | } | ||
171 | if (~flags & frameless_WidgetFlag) { | ||
172 | iRect frameRect = adjusted_Rect(rect, zero_I2(), init1_I2(-1)); | ||
173 | if (isButton) { | ||
174 | iInt2 points[] = { | ||
175 | bottomLeft_Rect(frameRect), topLeft_Rect(frameRect), topRight_Rect(frameRect), | ||
176 | bottomRight_Rect(frameRect), bottomLeft_Rect(frameRect) | ||
177 | }; | ||
178 | drawLines_Paint(&p, points + 2, 3, frame2); | ||
179 | drawLines_Paint(&p, points, 3, frame); | ||
180 | } | ||
181 | else { | ||
182 | drawRect_Paint(&p, frameRect, frame); | ||
183 | } | ||
184 | } | ||
185 | setClip_Paint(&p, rect); | ||
186 | if (flags & alignLeft_WidgetFlag) { | ||
187 | draw_Text(d->font, add_I2(bounds.pos, padding_()), fg, cstr_String(&d->label)); | ||
188 | if ((flags & drawKey_WidgetFlag) && d->key) { | ||
189 | iString str; | ||
190 | init_String(&str); | ||
191 | keyStr_LabelWidget_(d, &str); | ||
192 | draw_Text(uiShortcuts_FontId, negX_I2(add_I2(topRight_Rect(bounds), negX_I2(padding_()))), | ||
193 | flags & pressed_WidgetFlag ? fg : cyan_ColorId, cstr_String(&str)); | ||
194 | deinit_String(&str); | ||
195 | } | ||
196 | } | ||
197 | else if (flags & alignRight_WidgetFlag) { | ||
198 | draw_Text( | ||
199 | d->font, | ||
200 | mul_I2(init_I2(-1, 1), add_I2(topRight_Rect(bounds), negX_I2(padding_()))), | ||
201 | fg, | ||
202 | cstr_String(&d->label)); | ||
203 | } | ||
204 | else { | ||
205 | drawCentered_Text(d->font, bounds, fg, cstr_String(&d->label)); | ||
206 | } | ||
207 | clearClip_Paint(&p); | ||
208 | } | ||
209 | |||
210 | void updateSize_LabelWidget(iLabelWidget *d) { | ||
211 | iWidget *w = as_Widget(d); | ||
212 | const int flags = flags_Widget(w); | ||
213 | iInt2 size = add_I2(measure_Text(d->font, cstr_String(&d->label)), muli_I2(padding_(), 2)); | ||
214 | if ((flags & drawKey_WidgetFlag) && d->key) { | ||
215 | iString str; | ||
216 | init_String(&str); | ||
217 | keyStr_LabelWidget_(d, &str); | ||
218 | size.x += 2 * gap_UI + measure_Text(uiShortcuts_FontId, cstr_String(&str)).x; | ||
219 | deinit_String(&str); | ||
220 | } | ||
221 | if (~flags & fixedWidth_WidgetFlag) { | ||
222 | w->rect.size.x = size.x; | ||
223 | } | ||
224 | if (~flags & fixedHeight_WidgetFlag) { | ||
225 | w->rect.size.y = size.y; | ||
226 | } | ||
227 | } | ||
228 | |||
229 | void init_LabelWidget(iLabelWidget *d, const char *label, int key, int kmods, const char *cmd) { | ||
230 | init_Widget(&d->widget); | ||
231 | d->font = default_FontId; | ||
232 | initCStr_String(&d->label, label); | ||
233 | if (cmd) { | ||
234 | initCStr_String(&d->command, cmd); | ||
235 | } | ||
236 | else { | ||
237 | init_String(&d->command); | ||
238 | } | ||
239 | d->key = key; | ||
240 | d->kmods = kmods; | ||
241 | init_Click(&d->click, d, !isEmpty_String(&d->command) ? SDL_BUTTON_LEFT : 0); | ||
242 | setFlags_Widget(&d->widget, hover_WidgetFlag, d->click.button != 0); | ||
243 | updateSize_LabelWidget(d); | ||
244 | } | ||
245 | |||
246 | void deinit_LabelWidget(iLabelWidget *d) { | ||
247 | deinit_String(&d->label); | ||
248 | deinit_String(&d->command); | ||
249 | } | ||
250 | |||
251 | void setFont_LabelWidget(iLabelWidget *d, int fontId) { | ||
252 | d->font = fontId; | ||
253 | updateSize_LabelWidget(d); | ||
254 | } | ||
255 | |||
256 | void setText_LabelWidget(iLabelWidget *d, const iString *text) { | ||
257 | updateText_LabelWidget(d, text); | ||
258 | updateSize_LabelWidget(d); | ||
259 | } | ||
260 | |||
261 | void updateText_LabelWidget(iLabelWidget *d, const iString *text) { | ||
262 | set_String(&d->label, text); | ||
263 | } | ||
264 | |||
265 | void updateTextCStr_LabelWidget(iLabelWidget *d, const char *text) { | ||
266 | setCStr_String(&d->label, text); | ||
267 | } | ||
268 | |||
269 | void setTextCStr_LabelWidget(iLabelWidget *d, const char *text) { | ||
270 | setCStr_String(&d->label, text); | ||
271 | updateSize_LabelWidget(d); | ||
272 | } | ||
273 | |||
274 | const iString *command_LabelWidget(const iLabelWidget *d) { | ||
275 | return &d->command; | ||
276 | } | ||
277 | |||
278 | iBeginDefineSubclass(LabelWidget, Widget) | ||
279 | .processEvent = (iAny *) processEvent_LabelWidget_, | ||
280 | .draw = (iAny *) draw_LabelWidget_, | ||
281 | iEndDefineSubclass(LabelWidget) | ||
diff --git a/src/ui/labelwidget.h b/src/ui/labelwidget.h new file mode 100644 index 00000000..0563728e --- /dev/null +++ b/src/ui/labelwidget.h | |||
@@ -0,0 +1,22 @@ | |||
1 | #pragma once | ||
2 | |||
3 | /* Text label/button. */ | ||
4 | |||
5 | #include "widget.h" | ||
6 | |||
7 | iDeclareWidgetClass(LabelWidget) | ||
8 | iDeclareObjectConstructionArgs(LabelWidget, const char *label, int key, int kmods, const char *command) | ||
9 | |||
10 | iLocalDef iLabelWidget *newEmpty_LabelWidget(void) { | ||
11 | return new_LabelWidget("", 0, 0, NULL); | ||
12 | } | ||
13 | |||
14 | void setFont_LabelWidget (iLabelWidget *, int fontId); | ||
15 | void setText_LabelWidget (iLabelWidget *, const iString *text); /* resizes widget */ | ||
16 | void setTextCStr_LabelWidget (iLabelWidget *, const char *text); | ||
17 | |||
18 | void updateSize_LabelWidget (iLabelWidget *); | ||
19 | void updateText_LabelWidget (iLabelWidget *, const iString *text); /* not resized */ | ||
20 | void updateTextCStr_LabelWidget (iLabelWidget *, const char *text); /* not resized */ | ||
21 | |||
22 | const iString *command_LabelWidget (const iLabelWidget *); | ||
diff --git a/src/ui/macos.h b/src/ui/macos.h new file mode 100644 index 00000000..bb991a61 --- /dev/null +++ b/src/ui/macos.h | |||
@@ -0,0 +1,9 @@ | |||
1 | #pragma once | ||
2 | |||
3 | #include "util.h" | ||
4 | |||
5 | /* Platform-specific functionality for macOS */ | ||
6 | |||
7 | void setupApplication_MacOS (void); | ||
8 | void insertMenuItems_MacOS (const char *menuLabel, const iMenuItem *items, size_t count); | ||
9 | void handleCommand_MacOS (const char *cmd); | ||
diff --git a/src/ui/macos.m b/src/ui/macos.m new file mode 100644 index 00000000..73e17a4c --- /dev/null +++ b/src/ui/macos.m | |||
@@ -0,0 +1,434 @@ | |||
1 | #include "macos.h" | ||
2 | #include "app.h" | ||
3 | #include "command.h" | ||
4 | #include "widget.h" | ||
5 | #include "color.h" | ||
6 | |||
7 | #import <AppKit/AppKit.h> | ||
8 | |||
9 | #if 0 | ||
10 | static NSTouchBarItemIdentifier play_TouchId_ = @"fi.skyjake.BitwiseHarmony.play"; | ||
11 | static NSTouchBarItemIdentifier restart_TouchId_ = @"fi.skyjake.BitwiseHarmony.restart"; | ||
12 | |||
13 | static NSTouchBarItemIdentifier seqMoveUp_TouchId_ = @"fi.skyjake.BitwiseHarmony.sequence.move.up"; | ||
14 | static NSTouchBarItemIdentifier seqMoveDown_TouchId_ = @"fi.skyjake.BitwiseHarmony.sequence.move.down"; | ||
15 | |||
16 | static NSTouchBarItemIdentifier goto_TouchId_ = @"fi.skyjake.BitwiseHarmony.goto"; | ||
17 | static NSTouchBarItemIdentifier mute_TouchId_ = @"fi.skyjake.BitwiseHarmony.mute"; | ||
18 | static NSTouchBarItemIdentifier solo_TouchId_ = @"fi.skyjake.BitwiseHarmony.solo"; | ||
19 | static NSTouchBarItemIdentifier color_TouchId_ = @"fi.skyjake.BitwiseHarmony.color"; | ||
20 | static NSTouchBarItemIdentifier event_TouchId_ = @"fi.skyjake.BitwiseHarmony.event"; | ||
21 | |||
22 | static NSTouchBarItemIdentifier eventList_TouchId_ = @"fi.skyjake.BitwiseHarmony.eventlist"; | ||
23 | static NSTouchBarItemIdentifier masterGainEvent_TouchId_ = @"fi.skyjake.BitwiseHarmony.event.mastergain"; | ||
24 | static NSTouchBarItemIdentifier resetEvent_TouchId_ = @"fi.skyjake.BitwiseHarmony.event.reset"; | ||
25 | static NSTouchBarItemIdentifier voiceEvent_TouchId_ = @"fi.skyjake.BitwiseHarmony.event.voice"; | ||
26 | static NSTouchBarItemIdentifier panEvent_TouchId_ = @"fi.skyjake.BitwiseHarmony.event.pan"; | ||
27 | static NSTouchBarItemIdentifier gainEvent_TouchId_ = @"fi.skyjake.BitwiseHarmony.event.gain"; | ||
28 | static NSTouchBarItemIdentifier fadeEvent_TouchId_ = @"fi.skyjake.BitwiseHarmony.event.fade"; | ||
29 | static NSTouchBarItemIdentifier pitchSpeedEvent_TouchId_ = @"fi.skyjake.BitwiseHarmony.event.pitchspeed"; | ||
30 | static NSTouchBarItemIdentifier pitchBendUpEvent_TouchId_ = @"fi.skyjake.BitwiseHarmony.event.pitchbendup"; | ||
31 | static NSTouchBarItemIdentifier pitchBendDownEvent_TouchId_ = @"fi.skyjake.BitwiseHarmony.event.pitchbenddown"; | ||
32 | static NSTouchBarItemIdentifier tremoloEvent_TouchId_ = @"fi.skyjake.BitwiseHarmony.event.tremolo"; | ||
33 | #endif | ||
34 | |||
35 | enum iTouchBarVariant { | ||
36 | default_TouchBarVariant, | ||
37 | sequence_TouchBarVariant, | ||
38 | tracker_TouchBarVariant, | ||
39 | wide_TouchBarVariant, | ||
40 | }; | ||
41 | |||
42 | @interface CommandButton : NSButtonTouchBarItem { | ||
43 | NSString *command; | ||
44 | iWidget *widget; | ||
45 | } | ||
46 | - (id)initWithIdentifier:(NSTouchBarItemIdentifier)identifier | ||
47 | title:(NSString *)title | ||
48 | command:(NSString *)cmd; | ||
49 | - (id)initWithIdentifier:(NSTouchBarItemIdentifier)identifier | ||
50 | title:(NSString *)title | ||
51 | widget:(iWidget *)widget | ||
52 | command:(NSString *)cmd; | ||
53 | - (void)dealloc; | ||
54 | @end | ||
55 | |||
56 | @implementation CommandButton | ||
57 | |||
58 | - (id)initWithIdentifier:(NSTouchBarItemIdentifier)identifier | ||
59 | title:(NSString *)title | ||
60 | command:(NSString *)cmd { | ||
61 | [super initWithIdentifier:identifier]; | ||
62 | self.title = title; | ||
63 | self.target = self; | ||
64 | self.action = @selector(buttonPressed); | ||
65 | command = cmd; | ||
66 | return self; | ||
67 | } | ||
68 | |||
69 | - (id)initWithIdentifier:(NSTouchBarItemIdentifier)identifier | ||
70 | title:(NSString *)title | ||
71 | widget:(iWidget *)aWidget | ||
72 | command:(NSString *)cmd { | ||
73 | [self initWithIdentifier:identifier title:title command:[cmd retain]]; | ||
74 | widget = aWidget; | ||
75 | return self; | ||
76 | } | ||
77 | |||
78 | - (void)dealloc { | ||
79 | [command release]; | ||
80 | [super dealloc]; | ||
81 | } | ||
82 | |||
83 | - (void)buttonPressed { | ||
84 | const char *cmd = [command cStringUsingEncoding:NSUTF8StringEncoding]; | ||
85 | if (widget) { | ||
86 | postCommand_Widget(widget, "%s", cmd); | ||
87 | } | ||
88 | else { | ||
89 | postCommand_App(cmd); | ||
90 | } | ||
91 | } | ||
92 | |||
93 | @end | ||
94 | |||
95 | @interface MyDelegate : NSResponder<NSApplicationDelegate, NSTouchBarDelegate> { | ||
96 | enum iTouchBarVariant touchBarVariant; | ||
97 | NSObject<NSApplicationDelegate> *sdlDelegate; | ||
98 | NSMutableDictionary<NSString *, NSString*> *menuCommands; | ||
99 | } | ||
100 | - (id)initWithSDLDelegate:(NSObject<NSApplicationDelegate> *)sdl; | ||
101 | - (NSTouchBar *)makeTouchBar; | ||
102 | /* SDL needs to do its own thing. */ | ||
103 | - (BOOL)application:(NSApplication *)theApplication openFile:(NSString *)filename; | ||
104 | - (void)applicationDidFinishLaunching:(NSNotification *)notificatiosn; | ||
105 | @end | ||
106 | |||
107 | @implementation MyDelegate | ||
108 | |||
109 | - (id)initWithSDLDelegate:(NSObject<NSApplicationDelegate> *)sdl { | ||
110 | [super init]; | ||
111 | menuCommands = [[NSMutableDictionary<NSString *, NSString *> alloc] init]; | ||
112 | touchBarVariant = default_TouchBarVariant; | ||
113 | sdlDelegate = sdl; | ||
114 | return self; | ||
115 | } | ||
116 | |||
117 | - (void)dealloc { | ||
118 | [menuCommands release]; | ||
119 | [super dealloc]; | ||
120 | } | ||
121 | |||
122 | - (void)setTouchBarVariant:(enum iTouchBarVariant)variant { | ||
123 | touchBarVariant = variant; | ||
124 | self.touchBar = nil; | ||
125 | } | ||
126 | |||
127 | - (void)setCommand:(NSString *)command forMenuItem:(NSMenuItem *)menuItem { | ||
128 | [menuCommands setObject:command forKey:[menuItem title]]; | ||
129 | } | ||
130 | |||
131 | - (BOOL)application:(NSApplication *)theApplication openFile:(NSString *)filename { | ||
132 | return [sdlDelegate application:theApplication openFile:filename]; | ||
133 | } | ||
134 | |||
135 | - (void)applicationDidFinishLaunching:(NSNotification *)notification { | ||
136 | [sdlDelegate applicationDidFinishLaunching:notification]; | ||
137 | } | ||
138 | |||
139 | - (NSTouchBar *)makeTouchBar { | ||
140 | NSTouchBar *bar = [[NSTouchBar alloc] init]; | ||
141 | bar.delegate = self; | ||
142 | #if 0 | ||
143 | switch (touchBarVariant) { | ||
144 | case default_TouchBarVariant: | ||
145 | bar.defaultItemIdentifiers = @[ play_TouchId_, restart_TouchId_, | ||
146 | NSTouchBarItemIdentifierFixedSpaceSmall, | ||
147 | NSTouchBarItemIdentifierOtherItemsProxy ]; | ||
148 | break; | ||
149 | case sequence_TouchBarVariant: | ||
150 | bar.defaultItemIdentifiers = @[ play_TouchId_, restart_TouchId_, | ||
151 | NSTouchBarItemIdentifierFlexibleSpace, | ||
152 | seqMoveUp_TouchId_, seqMoveDown_TouchId_, | ||
153 | NSTouchBarItemIdentifierFlexibleSpace, | ||
154 | NSTouchBarItemIdentifierOtherItemsProxy]; | ||
155 | break; | ||
156 | case tracker_TouchBarVariant: | ||
157 | bar.defaultItemIdentifiers = @[ play_TouchId_, restart_TouchId_, | ||
158 | NSTouchBarItemIdentifierFlexibleSpace, | ||
159 | goto_TouchId_, | ||
160 | event_TouchId_, | ||
161 | NSTouchBarItemIdentifierFlexibleSpace, | ||
162 | solo_TouchId_, mute_TouchId_, color_TouchId_, | ||
163 | NSTouchBarItemIdentifierFlexibleSpace, | ||
164 | NSTouchBarItemIdentifierOtherItemsProxy ]; | ||
165 | break; | ||
166 | case wide_TouchBarVariant: | ||
167 | bar.defaultItemIdentifiers = @[ play_TouchId_, restart_TouchId_, | ||
168 | NSTouchBarItemIdentifierFlexibleSpace, | ||
169 | event_TouchId_, | ||
170 | NSTouchBarItemIdentifierFlexibleSpace, | ||
171 | solo_TouchId_, mute_TouchId_, color_TouchId_, | ||
172 | NSTouchBarItemIdentifierFlexibleSpace, | ||
173 | seqMoveUp_TouchId_, seqMoveDown_TouchId_, | ||
174 | NSTouchBarItemIdentifierFlexibleSpace, | ||
175 | NSTouchBarItemIdentifierOtherItemsProxy ]; | ||
176 | break; | ||
177 | } | ||
178 | #endif | ||
179 | return bar; | ||
180 | } | ||
181 | |||
182 | - (void)playPressed { | ||
183 | postCommand_App("playback.toggle"); | ||
184 | } | ||
185 | |||
186 | - (void)restartPressed { | ||
187 | postCommand_App("playback.restart"); | ||
188 | } | ||
189 | |||
190 | - (void)showPreferences { | ||
191 | postCommand_App("preferences"); | ||
192 | } | ||
193 | |||
194 | - (void)postMenuItemCommand:(id)sender { | ||
195 | NSString *command = [menuCommands objectForKey:[(NSMenuItem *)sender title]]; | ||
196 | if (command) { | ||
197 | postCommand_App([command cStringUsingEncoding:NSUTF8StringEncoding]); | ||
198 | } | ||
199 | } | ||
200 | |||
201 | - (nullable NSTouchBarItem *)touchBar:(NSTouchBar *)touchBar | ||
202 | makeItemForIdentifier:(NSTouchBarItemIdentifier)identifier { | ||
203 | iUnused(touchBar); | ||
204 | #if 0 | ||
205 | if ([identifier isEqualToString:play_TouchId_]) { | ||
206 | return [NSButtonTouchBarItem | ||
207 | buttonTouchBarItemWithIdentifier:identifier | ||
208 | image:[NSImage imageNamed:NSImageNameTouchBarPlayPauseTemplate] | ||
209 | target:self | ||
210 | action:@selector(playPressed)]; | ||
211 | } | ||
212 | else if ([identifier isEqualToString:restart_TouchId_]) { | ||
213 | return [NSButtonTouchBarItem | ||
214 | buttonTouchBarItemWithIdentifier:identifier | ||
215 | image:[NSImage imageNamed:NSImageNameTouchBarSkipToStartTemplate] | ||
216 | target:self | ||
217 | action:@selector(restartPressed)]; | ||
218 | } | ||
219 | else if ([identifier isEqualToString:seqMoveUp_TouchId_]) { | ||
220 | return [[CommandButton alloc] initWithIdentifier:identifier | ||
221 | title:@"Seq\u2b06" | ||
222 | widget:findWidget_App("sequence") | ||
223 | command:@"sequence.swap arg:-1"]; | ||
224 | } | ||
225 | else if ([identifier isEqualToString:seqMoveDown_TouchId_]) { | ||
226 | return [[CommandButton alloc] initWithIdentifier:identifier | ||
227 | title:@"Seq\u2b07" | ||
228 | widget:findWidget_App("sequence") | ||
229 | command:@"sequence.swap arg:1"]; | ||
230 | } | ||
231 | else if ([identifier isEqualToString:goto_TouchId_]) { | ||
232 | return [[CommandButton alloc] initWithIdentifier:identifier | ||
233 | title:@"Go to…" | ||
234 | command:@"pattern.goto arg:-1"]; | ||
235 | } | ||
236 | else if ([identifier isEqualToString:event_TouchId_]) { | ||
237 | NSTouchBar *events = [[NSTouchBar alloc] init]; | ||
238 | events.delegate = self; | ||
239 | events.defaultItemIdentifiers = @[ eventList_TouchId_ ]; | ||
240 | NSPopoverTouchBarItem *pop = [[NSPopoverTouchBarItem alloc] initWithIdentifier:identifier]; | ||
241 | pop.collapsedRepresentationLabel = @"Event"; | ||
242 | pop.popoverTouchBar = events; | ||
243 | [events release]; | ||
244 | return pop; | ||
245 | } | ||
246 | else if ([identifier isEqualToString:eventList_TouchId_]) { | ||
247 | const struct { | ||
248 | NSTouchBarItemIdentifier id; | ||
249 | const char *title; | ||
250 | const char *command; | ||
251 | } buttonDefs_[] = { | ||
252 | { voiceEvent_TouchId_, "Voice", "tracker.setevent type:2" }, | ||
253 | { panEvent_TouchId_, "Pan", "tracker.setevent type:3 arg:128" }, | ||
254 | { gainEvent_TouchId_, "Gain", "tracker.setevent type:4 arg:128" }, | ||
255 | { fadeEvent_TouchId_, "Fade", "tracker.setevent type:5" }, | ||
256 | { tremoloEvent_TouchId_, "Trem", "tracker.setevent type:9" }, | ||
257 | { pitchSpeedEvent_TouchId_, "P.Spd", "tracker.setevent type:6" }, | ||
258 | { pitchBendUpEvent_TouchId_, "BnUp", "tracker.setevent type:7" }, | ||
259 | { pitchBendDownEvent_TouchId_, "BnDn", "tracker.setevent type:8" }, | ||
260 | { masterGainEvent_TouchId_, "M.Gain", "tracker.setevent type:10 arg:64" }, | ||
261 | { resetEvent_TouchId_, "Reset", "tracker.setevent type:1" }, | ||
262 | }; | ||
263 | NSMutableArray *items = [[NSMutableArray alloc] init]; | ||
264 | iForIndices(i, buttonDefs_) { | ||
265 | CommandButton *button = [[CommandButton alloc] | ||
266 | initWithIdentifier:buttonDefs_[i].id | ||
267 | title:[NSString stringWithUTF8String:buttonDefs_[i].title] | ||
268 | widget:findWidget_App("tracker") | ||
269 | command:[NSString stringWithUTF8String:buttonDefs_[i].command] | ||
270 | ]; | ||
271 | [items addObject:button]; | ||
272 | } | ||
273 | NSGroupTouchBarItem *group = [NSGroupTouchBarItem groupItemWithIdentifier:identifier | ||
274 | items:items]; | ||
275 | [items release]; | ||
276 | return group; | ||
277 | } | ||
278 | else if ([identifier isEqualToString:mute_TouchId_]) { | ||
279 | return [[CommandButton alloc] initWithIdentifier:identifier | ||
280 | title:@"Mute" | ||
281 | widget:findWidget_App("tracker") | ||
282 | command:@"tracker.mute"]; | ||
283 | } | ||
284 | else if ([identifier isEqualToString:solo_TouchId_]) { | ||
285 | return [[CommandButton alloc] initWithIdentifier:identifier | ||
286 | title:@"Solo" | ||
287 | widget:findWidget_App("tracker") | ||
288 | command:@"tracker.solo"]; | ||
289 | } | ||
290 | else if ([identifier isEqualToString:color_TouchId_]) { | ||
291 | NSTouchBar *colors = [[NSTouchBar alloc] init]; | ||
292 | colors.delegate = self; | ||
293 | colors.defaultItemIdentifiers = @[ NSTouchBarItemIdentifierFlexibleSpace, | ||
294 | whiteColor_TouchId_, | ||
295 | yellowColor_TouchId_, | ||
296 | orangeColor_TouchId_, | ||
297 | redColor_TouchId_, | ||
298 | magentaColor_TouchId_, | ||
299 | blueColor_TouchId_, | ||
300 | cyanColor_TouchId_, | ||
301 | greenColor_TouchId_, | ||
302 | NSTouchBarItemIdentifierFlexibleSpace ]; | ||
303 | NSPopoverTouchBarItem *pop = [[NSPopoverTouchBarItem alloc] initWithIdentifier:identifier]; | ||
304 | pop.collapsedRepresentationImage = [NSImage imageNamed:NSImageNameTouchBarColorPickerFill]; | ||
305 | pop.popoverTouchBar = colors; | ||
306 | [colors release]; | ||
307 | return pop; | ||
308 | } | ||
309 | else if ([identifier isEqualToString:whiteColor_TouchId_]) { | ||
310 | return [[ColorButton alloc] initWithIdentifier:identifier | ||
311 | trackColor:white_TrackColor]; | ||
312 | } | ||
313 | else if ([identifier isEqualToString:yellowColor_TouchId_]) { | ||
314 | return [[ColorButton alloc] initWithIdentifier:identifier | ||
315 | trackColor:yellow_TrackColor]; | ||
316 | } | ||
317 | else if ([identifier isEqualToString:orangeColor_TouchId_]) { | ||
318 | return [[ColorButton alloc] initWithIdentifier:identifier | ||
319 | trackColor:orange_TrackColor]; | ||
320 | } | ||
321 | else if ([identifier isEqualToString:redColor_TouchId_]) { | ||
322 | return [[ColorButton alloc] initWithIdentifier:identifier | ||
323 | trackColor:red_TrackColor]; | ||
324 | } | ||
325 | else if ([identifier isEqualToString:magentaColor_TouchId_]) { | ||
326 | return [[ColorButton alloc] initWithIdentifier:identifier | ||
327 | trackColor:magenta_TrackColor]; | ||
328 | } | ||
329 | else if ([identifier isEqualToString:blueColor_TouchId_]) { | ||
330 | return [[ColorButton alloc] initWithIdentifier:identifier | ||
331 | trackColor:blue_TrackColor]; | ||
332 | } | ||
333 | else if ([identifier isEqualToString:cyanColor_TouchId_]) { | ||
334 | return [[ColorButton alloc] initWithIdentifier:identifier | ||
335 | trackColor:cyan_TrackColor]; | ||
336 | } | ||
337 | else if ([identifier isEqualToString:greenColor_TouchId_]) { | ||
338 | return [[ColorButton alloc] initWithIdentifier:identifier | ||
339 | trackColor:green_TrackColor]; | ||
340 | } | ||
341 | #endif | ||
342 | return nil; | ||
343 | } | ||
344 | |||
345 | @end | ||
346 | |||
347 | void setupApplication_MacOS(void) { | ||
348 | NSApplication *app = [NSApplication sharedApplication]; | ||
349 | /* Our delegate will override SDL's delegate. */ | ||
350 | MyDelegate *myDel = [[MyDelegate alloc] initWithSDLDelegate:app.delegate]; | ||
351 | app.delegate = myDel; | ||
352 | NSMenu *appMenu = [[[NSApp mainMenu] itemAtIndex:0] submenu]; | ||
353 | NSMenuItem *prefsItem = [appMenu itemWithTitle:@"Preferences…"]; | ||
354 | prefsItem.target = myDel; | ||
355 | prefsItem.action = @selector(showPreferences); | ||
356 | } | ||
357 | |||
358 | void insertMenuItems_MacOS(const char *menuLabel, const iMenuItem *items, size_t count) { | ||
359 | NSApplication *app = [NSApplication sharedApplication]; | ||
360 | MyDelegate *myDel = (MyDelegate *) app.delegate; | ||
361 | NSMenu *appMenu = [app mainMenu]; | ||
362 | NSMenuItem *mainItem = [appMenu insertItemWithTitle:[NSString stringWithUTF8String:menuLabel] | ||
363 | action:nil | ||
364 | keyEquivalent:@"" | ||
365 | atIndex:(iCmpStr(menuLabel, "File") == 0 ? 1 : | ||
366 | iCmpStr(menuLabel, "Edit") == 0 ? 2 : 3)]; | ||
367 | NSMenu *menu = [[NSMenu alloc] initWithTitle:[NSString stringWithUTF8String:menuLabel]]; | ||
368 | for (size_t i = 0; i < count; ++i) { | ||
369 | const char *label = items[i].label; | ||
370 | if (label[0] == '\r') { | ||
371 | /* Skip the formatting escape. */ | ||
372 | label += 2; | ||
373 | } | ||
374 | if (equal_CStr(label, "---")) { | ||
375 | [menu addItem:[NSMenuItem separatorItem]]; | ||
376 | } | ||
377 | else { | ||
378 | const iBool hasCommand = (items[i].command && items[i].command[0]); | ||
379 | iString key; | ||
380 | init_String(&key); | ||
381 | if (items[i].key == SDLK_LEFT) { | ||
382 | appendChar_String(&key, 0x2190); | ||
383 | } | ||
384 | else if (items[i].key == SDLK_RIGHT) { | ||
385 | appendChar_String(&key, 0x2192); | ||
386 | } | ||
387 | else if (items[i].key) { | ||
388 | appendChar_String(&key, items[i].key); | ||
389 | } | ||
390 | NSMenuItem *item = [menu addItemWithTitle:[NSString stringWithUTF8String:label] | ||
391 | action:(hasCommand ? @selector(postMenuItemCommand:) : nil) | ||
392 | keyEquivalent:[NSString stringWithUTF8String:cstr_String(&key)]]; | ||
393 | NSEventModifierFlags modMask = 0; | ||
394 | if (items[i].kmods & KMOD_GUI) { | ||
395 | modMask |= NSEventModifierFlagCommand; | ||
396 | } | ||
397 | if (items[i].kmods & KMOD_ALT) { | ||
398 | modMask |= NSEventModifierFlagOption; | ||
399 | } | ||
400 | if (items[i].kmods & KMOD_CTRL) { | ||
401 | modMask |= NSEventModifierFlagControl; | ||
402 | } | ||
403 | if (items[i].kmods & KMOD_SHIFT) { | ||
404 | modMask |= NSEventModifierFlagShift; | ||
405 | } | ||
406 | [item setKeyEquivalentModifierMask:modMask]; | ||
407 | if (hasCommand) { | ||
408 | [myDel setCommand:[NSString stringWithUTF8String:items[i].command] forMenuItem:item]; | ||
409 | } | ||
410 | deinit_String(&key); | ||
411 | } | ||
412 | } | ||
413 | [mainItem setSubmenu:menu]; | ||
414 | [menu release]; | ||
415 | } | ||
416 | |||
417 | void handleCommand_MacOS(const char *cmd) { | ||
418 | if (equal_Command(cmd, "tabs.changed")) { | ||
419 | MyDelegate *myDel = (MyDelegate *) [[NSApplication sharedApplication] delegate]; | ||
420 | const char *tabId = valuePtr_Command(cmd, "id"); | ||
421 | if (equal_CStr(tabId, "tracker")) { | ||
422 | [myDel setTouchBarVariant:tracker_TouchBarVariant]; | ||
423 | } | ||
424 | else if (equal_CStr(tabId, "sequence")) { | ||
425 | [myDel setTouchBarVariant:sequence_TouchBarVariant]; | ||
426 | } | ||
427 | else if (equal_CStr(tabId, "trackertab")) { | ||
428 | [myDel setTouchBarVariant:wide_TouchBarVariant]; | ||
429 | } | ||
430 | else { | ||
431 | [myDel setTouchBarVariant:default_TouchBarVariant]; | ||
432 | } | ||
433 | } | ||
434 | } | ||
diff --git a/src/ui/metrics.c b/src/ui/metrics.c new file mode 100644 index 00000000..38ae5955 --- /dev/null +++ b/src/ui/metrics.c | |||
@@ -0,0 +1,16 @@ | |||
1 | #include "metrics.h" | ||
2 | |||
3 | #include <the_Foundation/math.h> | ||
4 | |||
5 | #define defaultFontSize_Metrics 16 | ||
6 | #define defaultGap_Metrics 4 | ||
7 | |||
8 | int gap_UI = defaultGap_Metrics; | ||
9 | iInt2 gap2_UI = { defaultGap_Metrics, defaultGap_Metrics }; | ||
10 | int fontSize_UI = defaultFontSize_Metrics; | ||
11 | |||
12 | void setPixelRatio_Metrics(float pixelRatio) { | ||
13 | gap_UI = iRound(defaultGap_Metrics * pixelRatio); | ||
14 | gap2_UI = init1_I2(gap_UI); | ||
15 | fontSize_UI = iRound(defaultFontSize_Metrics * pixelRatio); | ||
16 | } | ||
diff --git a/src/ui/metrics.h b/src/ui/metrics.h new file mode 100644 index 00000000..d59f726a --- /dev/null +++ b/src/ui/metrics.h | |||
@@ -0,0 +1,9 @@ | |||
1 | #pragma once | ||
2 | |||
3 | #include <the_Foundation/vec2.h> | ||
4 | |||
5 | extern int gap_UI; | ||
6 | extern int fontSize_UI; | ||
7 | extern iInt2 gap2_UI; | ||
8 | |||
9 | void setPixelRatio_Metrics (float pixelRatio); | ||
diff --git a/src/ui/paint.c b/src/ui/paint.c new file mode 100644 index 00000000..0a2e6cd3 --- /dev/null +++ b/src/ui/paint.c | |||
@@ -0,0 +1,58 @@ | |||
1 | #include "paint.h" | ||
2 | |||
3 | iLocalDef SDL_Renderer *renderer_Paint_(const iPaint *d) { | ||
4 | iAssert(d->dst); | ||
5 | return d->dst->render; | ||
6 | } | ||
7 | |||
8 | static void setColor_Paint_(const iPaint *d, int color) { | ||
9 | const iColor clr = get_Color(color & mask_ColorId); | ||
10 | SDL_SetRenderDrawColor(renderer_Paint_(d), clr.r, clr.g, clr.b, clr.a); | ||
11 | } | ||
12 | |||
13 | void init_Paint(iPaint *d) { | ||
14 | d->dst = get_Window(); | ||
15 | } | ||
16 | |||
17 | void setClip_Paint(iPaint *d, iRect rect) { | ||
18 | SDL_RenderSetClipRect(renderer_Paint_(d), (const SDL_Rect *) &rect); | ||
19 | } | ||
20 | |||
21 | void clearClip_Paint(iPaint *d) { | ||
22 | const SDL_Rect winRect = { 0, 0, d->dst->root->rect.size.x, d->dst->root->rect.size.y }; | ||
23 | SDL_RenderSetClipRect(renderer_Paint_(d), &winRect); | ||
24 | } | ||
25 | |||
26 | void drawRect_Paint(const iPaint *d, iRect rect, int color) { | ||
27 | iInt2 br = bottomRight_Rect(rect); | ||
28 | /* Keep the right/bottom edge visible in the window. */ | ||
29 | if (br.x == d->dst->root->rect.size.x) br.x--; | ||
30 | if (br.y == d->dst->root->rect.size.y) br.y--; | ||
31 | const SDL_Point edges[] = { | ||
32 | { left_Rect(rect), top_Rect(rect) }, | ||
33 | { br.x, top_Rect(rect) }, | ||
34 | { br.x, br.y }, | ||
35 | { left_Rect(rect), br.y }, | ||
36 | { left_Rect(rect), top_Rect(rect) } | ||
37 | }; | ||
38 | setColor_Paint_(d, color); | ||
39 | SDL_RenderDrawLines(renderer_Paint_(d), edges, iElemCount(edges)); | ||
40 | } | ||
41 | |||
42 | void drawRectThickness_Paint(const iPaint *d, iRect rect, int thickness, int color) { | ||
43 | thickness = iClamp(thickness, 1, 4); | ||
44 | while (thickness--) { | ||
45 | drawRect_Paint(d, rect, color); | ||
46 | shrink_Rect(&rect, one_I2()); | ||
47 | } | ||
48 | } | ||
49 | |||
50 | void fillRect_Paint(const iPaint *d, iRect rect, int color) { | ||
51 | setColor_Paint_(d, color); | ||
52 | SDL_RenderFillRect(renderer_Paint_(d), (SDL_Rect *) &rect); | ||
53 | } | ||
54 | |||
55 | void drawLines_Paint(const iPaint *d, const iInt2 *points, size_t count, int color) { | ||
56 | setColor_Paint_(d, color); | ||
57 | SDL_RenderDrawLines(renderer_Paint_(d), (const SDL_Point *) points, count); | ||
58 | } | ||
diff --git a/src/ui/paint.h b/src/ui/paint.h new file mode 100644 index 00000000..9535b142 --- /dev/null +++ b/src/ui/paint.h | |||
@@ -0,0 +1,33 @@ | |||
1 | #pragma once | ||
2 | |||
3 | #include <the_Foundation/rect.h> | ||
4 | #include "color.h" | ||
5 | #include "text.h" | ||
6 | #include "window.h" | ||
7 | |||
8 | iDeclareType(Paint) | ||
9 | |||
10 | struct Impl_Paint { | ||
11 | iWindow *dst; | ||
12 | }; | ||
13 | |||
14 | void init_Paint (iPaint *); | ||
15 | |||
16 | void setClip_Paint (iPaint *, iRect rect); | ||
17 | void clearClip_Paint (iPaint *); | ||
18 | |||
19 | void drawRect_Paint (const iPaint *, iRect rect, int color); | ||
20 | void drawRectThickness_Paint (const iPaint *, iRect rect, int thickness, int color); | ||
21 | void fillRect_Paint (const iPaint *, iRect rect, int color); | ||
22 | |||
23 | void drawLines_Paint (const iPaint *, const iInt2 *points, size_t count, int color); | ||
24 | |||
25 | iLocalDef void drawLine_Paint(const iPaint *d, iInt2 a, iInt2 b, int color) { | ||
26 | drawLines_Paint(d, (iInt2[]){ a, b }, 2, color); | ||
27 | } | ||
28 | iLocalDef void drawHLine_Paint(const iPaint *d, iInt2 pos, int len, int color) { | ||
29 | drawLine_Paint(d, pos, addX_I2(pos, len), color); | ||
30 | } | ||
31 | iLocalDef void drawVLine_Paint(const iPaint *d, iInt2 pos, int len, int color) { | ||
32 | drawLine_Paint(d, pos, addY_I2(pos, len), color); | ||
33 | } | ||
diff --git a/src/ui/text.c b/src/ui/text.c new file mode 100644 index 00000000..ac211481 --- /dev/null +++ b/src/ui/text.c | |||
@@ -0,0 +1,533 @@ | |||
1 | #include "text.h" | ||
2 | #include "color.h" | ||
3 | #include "metrics.h" | ||
4 | #include "embedded.h" | ||
5 | #include "app.h" | ||
6 | |||
7 | #define STB_TRUETYPE_IMPLEMENTATION | ||
8 | #include "../stb_truetype.h" | ||
9 | |||
10 | #include <the_Foundation/array.h> | ||
11 | #include <the_Foundation/file.h> | ||
12 | #include <the_Foundation/hash.h> | ||
13 | #include <the_Foundation/math.h> | ||
14 | #include <the_Foundation/path.h> | ||
15 | #include <the_Foundation/vec2.h> | ||
16 | |||
17 | #include <SDL_surface.h> | ||
18 | #include <stdarg.h> | ||
19 | |||
20 | iDeclareType(Glyph) | ||
21 | iDeclareTypeConstructionArgs(Glyph, iChar ch) | ||
22 | |||
23 | struct Impl_Glyph { | ||
24 | iHashNode node; | ||
25 | iRect rect; | ||
26 | int advance; | ||
27 | int dx, dy; | ||
28 | }; | ||
29 | |||
30 | void init_Glyph(iGlyph *d, iChar ch) { | ||
31 | d->node.key = ch; | ||
32 | d->rect = zero_Rect(); | ||
33 | d->advance = 0; | ||
34 | } | ||
35 | |||
36 | void deinit_Glyph(iGlyph *d) { | ||
37 | iUnused(d); | ||
38 | } | ||
39 | |||
40 | iChar char_Glyph(const iGlyph *d) { | ||
41 | return d->node.key; | ||
42 | } | ||
43 | |||
44 | iDefineTypeConstructionArgs(Glyph, (iChar ch), ch) | ||
45 | |||
46 | /*-----------------------------------------------------------------------------------------------*/ | ||
47 | |||
48 | iDeclareType(Font) | ||
49 | |||
50 | struct Impl_Font { | ||
51 | iBlock * data; | ||
52 | stbtt_fontinfo font; | ||
53 | float scale; | ||
54 | int height; | ||
55 | int baseline; | ||
56 | iHash glyphs; | ||
57 | }; | ||
58 | |||
59 | static void init_Font(iFont *d, const iBlock *data, int height) { | ||
60 | init_Hash(&d->glyphs); | ||
61 | d->data = NULL; | ||
62 | d->height = height; | ||
63 | iZap(d->font); | ||
64 | stbtt_InitFont(&d->font, constData_Block(data), 0); | ||
65 | d->scale = stbtt_ScaleForPixelHeight(&d->font, height); | ||
66 | int ascent; | ||
67 | stbtt_GetFontVMetrics(&d->font, &ascent, 0, 0); | ||
68 | d->baseline = (int) ascent * d->scale; | ||
69 | } | ||
70 | |||
71 | static void deinit_Font(iFont *d) { | ||
72 | iForEach(Hash, i, &d->glyphs) { | ||
73 | delete_Glyph((iGlyph *) i.value); | ||
74 | } | ||
75 | deinit_Hash(&d->glyphs); | ||
76 | delete_Block(d->data); | ||
77 | } | ||
78 | |||
79 | iDeclareType(Text) | ||
80 | |||
81 | struct Impl_Text { | ||
82 | iFont fonts[max_FontId]; | ||
83 | SDL_Renderer *render; | ||
84 | SDL_Texture * cache; | ||
85 | iInt2 cacheSize; | ||
86 | iInt2 cachePos; | ||
87 | int cacheRowHeight; | ||
88 | SDL_Palette * grayscale; | ||
89 | }; | ||
90 | |||
91 | static iText text_; | ||
92 | |||
93 | void init_Text(SDL_Renderer *render) { | ||
94 | iText *d = &text_; | ||
95 | d->render = render; | ||
96 | /* A grayscale palette for rasterized glyphs. */ { | ||
97 | SDL_Color colors[256]; | ||
98 | for (int i = 0; i < 256; ++i) { | ||
99 | colors[i] = (SDL_Color){ 255, 255, 255, i }; | ||
100 | } | ||
101 | d->grayscale = SDL_AllocPalette(256); | ||
102 | SDL_SetPaletteColors(d->grayscale, colors, 0, 256); | ||
103 | } | ||
104 | /* Initialize the glyph cache. */ { | ||
105 | d->cacheSize = init1_I2(fontSize_UI * 16); | ||
106 | d->cachePos = zero_I2(); | ||
107 | d->cache = SDL_CreateTexture(render, | ||
108 | SDL_PIXELFORMAT_RGBA8888, | ||
109 | SDL_TEXTUREACCESS_STATIC | SDL_TEXTUREACCESS_TARGET, | ||
110 | d->cacheSize.x, | ||
111 | d->cacheSize.y); | ||
112 | SDL_SetTextureBlendMode(d->cache, SDL_BLENDMODE_BLEND); | ||
113 | d->cacheRowHeight = 0; | ||
114 | } | ||
115 | /* Load the fonts. */ { | ||
116 | const struct { const iBlock *ttf; int size; } fontData[max_FontId] = { | ||
117 | { &fontFiraSansRegular_Embedded, fontSize_UI }, | ||
118 | { &fontFiraSansRegular_Embedded, fontSize_UI }, | ||
119 | { &fontFiraMonoRegular_Embedded, fontSize_UI }, | ||
120 | { &fontFiraSansRegular_Embedded, fontSize_UI }, | ||
121 | { &fontFiraSansRegular_Embedded, fontSize_UI * 1.5f }, | ||
122 | { &fontFiraMonoRegular_Embedded, fontSize_UI }, | ||
123 | { &fontFiraSansLightItalic_Embedded, fontSize_UI }, | ||
124 | { &fontFiraSansRegular_Embedded, fontSize_UI * 2.5f }, | ||
125 | { &fontFiraSansRegular_Embedded, fontSize_UI * 2.0f }, | ||
126 | { &fontFiraSansRegular_Embedded, fontSize_UI * 1.5f }, | ||
127 | }; | ||
128 | iForIndices(i, fontData) { | ||
129 | init_Font(&d->fonts[i], fontData[i].ttf, fontData[i].size); | ||
130 | } | ||
131 | } | ||
132 | } | ||
133 | |||
134 | void deinit_Text(void) { | ||
135 | iText *d = &text_; | ||
136 | SDL_FreePalette(d->grayscale); | ||
137 | iForIndices(i, d->fonts) { | ||
138 | deinit_Font(&d->fonts[i]); | ||
139 | } | ||
140 | SDL_DestroyTexture(d->cache); | ||
141 | d->render = NULL; | ||
142 | } | ||
143 | |||
144 | static SDL_Surface *rasterizeGlyph_Font_(const iFont *d, iChar ch) { | ||
145 | int w, h; | ||
146 | uint8_t *bmp = stbtt_GetCodepointBitmap(&d->font, d->scale, d->scale, ch, &w, &h, 0, 0); | ||
147 | /* Note: `bmp` must be freed afterwards. */ | ||
148 | SDL_Surface *surface = | ||
149 | SDL_CreateRGBSurfaceWithFormatFrom(bmp, w, h, 8, w, SDL_PIXELFORMAT_INDEX8); | ||
150 | SDL_SetSurfacePalette(surface, text_.grayscale); | ||
151 | return surface; | ||
152 | } | ||
153 | |||
154 | static iBool isSpecialChar_(iChar ch) { | ||
155 | return ch >= specialSymbol_Text && ch < 0x20; | ||
156 | } | ||
157 | |||
158 | static float symbolEmWidth_(int symbol) { | ||
159 | return 1.5f; | ||
160 | } | ||
161 | |||
162 | static float symbolAdvance_(int symbol) { | ||
163 | return 1.5f; | ||
164 | } | ||
165 | |||
166 | static int specialChar_(iChar ch) { | ||
167 | return ch - specialSymbol_Text; | ||
168 | } | ||
169 | |||
170 | iLocalDef SDL_Rect sdlRect_(const iRect rect) { | ||
171 | return (SDL_Rect){ rect.pos.x, rect.pos.y, rect.size.x, rect.size.y }; | ||
172 | } | ||
173 | |||
174 | static void fillTriangle_(SDL_Surface *surface, const SDL_Rect *rect, int dir) { | ||
175 | const uint32_t color = 0xffffffff; | ||
176 | SDL_LockSurface(surface); | ||
177 | uint32_t *row = surface->pixels; | ||
178 | row += rect->x + rect->y * surface->pitch / 4; | ||
179 | for (int y = 0; y < rect->h; y++, row += surface->pitch / 4) { | ||
180 | float norm = (float) y / (float) (rect->h - 1) * 2.0f; | ||
181 | if (norm > 1.0f) norm = 2.0f - norm; | ||
182 | const int len = norm * rect->w; | ||
183 | const float fract = norm * rect->w - len; | ||
184 | const uint32_t fractColor = 0xffffff00 | (int) (fract * 0xff); | ||
185 | if (dir > 0) { | ||
186 | for (int x = 0; x < len; x++) { | ||
187 | row[x] = color; | ||
188 | } | ||
189 | if (len < rect->w) { | ||
190 | row[len] = fractColor; | ||
191 | } | ||
192 | } | ||
193 | else { | ||
194 | for (int x = 0; x < len; x++) { | ||
195 | row[rect->w - len + x] = color; | ||
196 | } | ||
197 | if (len < rect->w) { | ||
198 | row[rect->w - len - 1] = fractColor; | ||
199 | } | ||
200 | } | ||
201 | } | ||
202 | SDL_UnlockSurface(surface); | ||
203 | } | ||
204 | |||
205 | static void cache_Font_(iFont *d, iGlyph *glyph) { | ||
206 | iText *txt = &text_; | ||
207 | SDL_Renderer *render = txt->render; | ||
208 | SDL_Texture *tex = NULL; | ||
209 | SDL_Surface *surface = NULL; | ||
210 | const iChar ch = char_Glyph(glyph); | ||
211 | iBool fromStb = iFalse; | ||
212 | if (!isSpecialChar_(ch)) { | ||
213 | /* Rasterize the glyph using stbtt. */ | ||
214 | surface = rasterizeGlyph_Font_(d, ch); | ||
215 | stbtt_GetCodepointBitmapBox( | ||
216 | &d->font, ch, d->scale, d->scale, &glyph->dx, &glyph->dy, NULL, NULL); | ||
217 | fromStb = iTrue; | ||
218 | tex = SDL_CreateTextureFromSurface(render, surface); | ||
219 | glyph->rect.size = init_I2(surface->w, surface->h); | ||
220 | } | ||
221 | else { | ||
222 | /* Metrics for special symbols. */ | ||
223 | int em, lsb; | ||
224 | const int symbol = specialChar_(ch); | ||
225 | stbtt_GetCodepointHMetrics(&d->font, 'M', &em, &lsb); | ||
226 | glyph->dx = d->baseline / 10; | ||
227 | glyph->dy = -d->baseline; | ||
228 | glyph->rect.size = init_I2(symbolEmWidth_(symbol) * em * d->scale, d->height); | ||
229 | #if 0 | ||
230 | if (isRasterizedSymbol_(ch)) { | ||
231 | /* Rasterize manually. */ | ||
232 | surface = SDL_CreateRGBSurfaceWithFormat( | ||
233 | 0, width_Rect(glyph->rect), height_Rect(glyph->rect), 32, SDL_PIXELFORMAT_RGBA8888); | ||
234 | SDL_FillRect(surface, NULL, 0); | ||
235 | const uint32_t white = 0xffffffff; | ||
236 | switch (specialChar_(ch)) { | ||
237 | case play_SpecialSymbol: | ||
238 | fillTriangle_(surface, &(SDL_Rect){ 0, 0, surface->w, d->baseline }, 1); | ||
239 | break; | ||
240 | case pause_SpecialSymbol: { | ||
241 | const int w = surface->w * 4 / 11; | ||
242 | SDL_FillRect(surface, &(SDL_Rect){ 0, 0, w, d->baseline }, white); | ||
243 | SDL_FillRect(surface, &(SDL_Rect){ surface->w - w, 0, w, d->baseline }, white); | ||
244 | break; | ||
245 | } | ||
246 | case rewind_SpecialSymbol: { | ||
247 | const int w1 = surface->w / 7; | ||
248 | const int w2 = surface->w * 3 / 7; | ||
249 | const int h = d->baseline * 4 / 5; | ||
250 | const int off = (d->baseline - h) / 2; | ||
251 | SDL_FillRect(surface, &(SDL_Rect){ 0, off, w1, h}, white); | ||
252 | fillTriangle_(surface, &(SDL_Rect){ w1, off, w2, h }, -1); | ||
253 | fillTriangle_(surface, &(SDL_Rect){ surface->w * 4 / 7, off, w2, h }, -1); | ||
254 | break; | ||
255 | } | ||
256 | } | ||
257 | tex = SDL_CreateTextureFromSurface(render, surface); | ||
258 | } | ||
259 | #endif | ||
260 | } | ||
261 | /* Determine placement in the glyph cache texture, advancing in rows. */ | ||
262 | if (txt->cachePos.x + glyph->rect.size.x > txt->cacheSize.x) { | ||
263 | txt->cachePos.x = 0; | ||
264 | txt->cachePos.y += txt->cacheRowHeight; | ||
265 | txt->cacheRowHeight = 0; | ||
266 | } | ||
267 | glyph->rect.pos = txt->cachePos; | ||
268 | SDL_SetRenderTarget(render, txt->cache); | ||
269 | const SDL_Rect dstRect = sdlRect_(glyph->rect); | ||
270 | if (surface) { | ||
271 | SDL_RenderCopy(render, tex, &(SDL_Rect){ 0, 0, dstRect.w, dstRect.h }, &dstRect); | ||
272 | } | ||
273 | else { | ||
274 | /* Draw a special symbol. */ | ||
275 | SDL_SetRenderDrawColor(render, 255, 255, 255, 255); | ||
276 | const iInt2 tl = init_I2(dstRect.x, dstRect.y); | ||
277 | const iInt2 br = init_I2(dstRect.x + dstRect.w - 1, dstRect.y + dstRect.h - 1); | ||
278 | const int midX = tl.x + dstRect.w / 2; | ||
279 | const int midY = tl.y + dstRect.h / 2; | ||
280 | const int symH = dstRect.h * 2 / 6; | ||
281 | #if 0 | ||
282 | /* Frame. */ | ||
283 | if (isFramedSymbol_(ch)) { | ||
284 | SDL_RenderDrawLines( | ||
285 | render, | ||
286 | (SDL_Point[]){ | ||
287 | { tl.x, tl.y }, { br.x, tl.y }, { br.x, br.y }, { tl.x, br.y }, { tl.x, tl.y } }, | ||
288 | 5); | ||
289 | } | ||
290 | iArray points; | ||
291 | init_Array(&points, sizeof(SDL_Point)); | ||
292 | switch (specialChar_(ch)) { | ||
293 | case 0: /* silence */ | ||
294 | break; | ||
295 | case 1: /* sine */ | ||
296 | for (int i = 0; i < dstRect.w; ++i) { | ||
297 | float rad = 2.0f * iMathPif * (float) i / dstRect.w; | ||
298 | SDL_Point pt = { tl.x + i, midY + sin(rad) * symH}; | ||
299 | pushBack_Array(&points, &pt); | ||
300 | } | ||
301 | SDL_RenderDrawLines(render, constData_Array(&points), size_Array(&points)); | ||
302 | break; | ||
303 | case 2: /* square */ | ||
304 | SDL_RenderDrawLines(render, | ||
305 | (SDL_Point[]){ { tl.x, midY - symH }, | ||
306 | { midX, midY - symH }, | ||
307 | { midX, midY + symH }, | ||
308 | { br.x, midY + symH } }, | ||
309 | 4); | ||
310 | break; | ||
311 | case 3: /* saw */ | ||
312 | SDL_RenderDrawLines(render, | ||
313 | (SDL_Point[]){ { tl.x, midY }, | ||
314 | { midX, midY - symH }, | ||
315 | { midX, midY + symH }, | ||
316 | { br.x, midY } }, | ||
317 | 4); | ||
318 | break; | ||
319 | case 4: /* triangle */ | ||
320 | SDL_RenderDrawLines(render, | ||
321 | (SDL_Point[]){ { tl.x, midY }, | ||
322 | { tl.x + dstRect.w / 4, midY - symH }, | ||
323 | { br.x - dstRect.w / 4, midY + symH }, | ||
324 | { br.x, midY } }, | ||
325 | 4); | ||
326 | break; | ||
327 | case 5: /* noise */ | ||
328 | for (int i = 0; i < dstRect.w; ++i) { | ||
329 | for (int p = 0; p < 2; ++p) { | ||
330 | const float val = iRandomf() * 2.0f - 1.0f; | ||
331 | pushBack_Array(&points, &(SDL_Point){ tl.x + i, midY - val * symH }); | ||
332 | } | ||
333 | } | ||
334 | SDL_RenderDrawPoints(render, constData_Array(&points), size_Array(&points)); | ||
335 | break; | ||
336 | } | ||
337 | deinit_Array(&points); | ||
338 | #endif | ||
339 | } | ||
340 | SDL_SetRenderTarget(render, NULL); | ||
341 | if (tex) { | ||
342 | SDL_DestroyTexture(tex); | ||
343 | iAssert(surface); | ||
344 | if (fromStb) stbtt_FreeBitmap(surface->pixels, NULL); | ||
345 | SDL_FreeSurface(surface); | ||
346 | } | ||
347 | /* Update cache cursor. */ | ||
348 | txt->cachePos.x += glyph->rect.size.x; | ||
349 | txt->cacheRowHeight = iMax(txt->cacheRowHeight, glyph->rect.size.y); | ||
350 | } | ||
351 | |||
352 | static const iGlyph *glyph_Font_(iFont *d, iChar ch) { | ||
353 | const void *node = value_Hash(&d->glyphs, ch); | ||
354 | if (node) { | ||
355 | return node; | ||
356 | } | ||
357 | iGlyph *glyph = new_Glyph(ch); | ||
358 | cache_Font_(d, glyph); | ||
359 | insert_Hash(&d->glyphs, &glyph->node); | ||
360 | return glyph; | ||
361 | } | ||
362 | |||
363 | enum iRunMode { measure_RunMode, draw_RunMode, drawPermanentColor_RunMode }; | ||
364 | |||
365 | static iInt2 run_Font_(iFont *d, enum iRunMode mode, const char *text, size_t maxLen, iInt2 pos, | ||
366 | int *runAdvance_out) { | ||
367 | iInt2 size = zero_I2(); | ||
368 | const iInt2 orig = pos; | ||
369 | const stbtt_fontinfo *info = &d->font; | ||
370 | float xpos = pos.x; | ||
371 | float xposMax = xpos; | ||
372 | const iString textStr = iStringLiteral(text); | ||
373 | iConstForEach(String, i, &textStr) { | ||
374 | iChar ch = i.value; | ||
375 | /* Special instructions. */ { | ||
376 | if (ch == '\n') { | ||
377 | xpos = pos.x; | ||
378 | pos.y += d->height; | ||
379 | continue; | ||
380 | } | ||
381 | if (ch == '\r') { | ||
382 | next_StringConstIterator(&i); | ||
383 | const iColor clr = get_Color(i.value - '0'); | ||
384 | if (mode == draw_RunMode) { | ||
385 | SDL_SetTextureColorMod(text_.cache, clr.r, clr.g, clr.b); | ||
386 | } | ||
387 | continue; | ||
388 | } | ||
389 | } | ||
390 | const iGlyph *glyph = glyph_Font_(d, ch); | ||
391 | int x1 = iRound(xpos); | ||
392 | int x2 = x1 + glyph->rect.size.x; | ||
393 | size.x = iMax(size.x, x2 - orig.x); | ||
394 | size.y = iMax(size.y, pos.y + d->height - orig.y); | ||
395 | if (mode != measure_RunMode) { | ||
396 | SDL_Rect dst = { x1 + glyph->dx, | ||
397 | pos.y + d->baseline + glyph->dy, | ||
398 | glyph->rect.size.x, | ||
399 | glyph->rect.size.y }; | ||
400 | SDL_RenderCopy(text_.render, text_.cache, (const SDL_Rect *) &glyph->rect, &dst); | ||
401 | } | ||
402 | int advance, lsb; | ||
403 | const iBool spec = isSpecialChar_(ch); | ||
404 | stbtt_GetCodepointHMetrics(info, spec ? 'M' : ch, &advance, &lsb); | ||
405 | if (spec) { | ||
406 | advance *= symbolAdvance_(specialChar_(ch)); | ||
407 | } | ||
408 | xpos += d->scale * advance; | ||
409 | xposMax = iMax(xposMax, xpos); | ||
410 | /* Check the next character. */ { | ||
411 | iStringConstIterator j = i; | ||
412 | next_StringConstIterator(&j); | ||
413 | const iChar next = j.value; | ||
414 | if (next) { | ||
415 | xpos += d->scale * stbtt_GetCodepointKernAdvance(info, ch, next); | ||
416 | } | ||
417 | } | ||
418 | if (--maxLen == 0) { | ||
419 | break; | ||
420 | } | ||
421 | } | ||
422 | if (runAdvance_out) { | ||
423 | *runAdvance_out = xposMax - orig.x; | ||
424 | } | ||
425 | return size; | ||
426 | } | ||
427 | |||
428 | int lineHeight_Text(int fontId) { | ||
429 | return text_.fonts[fontId].height; | ||
430 | } | ||
431 | |||
432 | iInt2 measure_Text(int fontId, const char *text) { | ||
433 | if (!*text) { | ||
434 | return init_I2(0, lineHeight_Text(fontId)); | ||
435 | } | ||
436 | return run_Font_(&text_.fonts[fontId], measure_RunMode, text, iInvalidSize, zero_I2(), NULL); | ||
437 | } | ||
438 | |||
439 | iInt2 advance_Text(int fontId, const char *text) { | ||
440 | int advance; | ||
441 | const int height = | ||
442 | run_Font_(&text_.fonts[fontId], measure_RunMode, text, iInvalidSize, zero_I2(), &advance).y; | ||
443 | return init_I2(advance, height); //lineHeight_Text(fontId)); | ||
444 | } | ||
445 | |||
446 | iInt2 advanceN_Text(int fontId, const char *text, size_t n) { | ||
447 | if (n == 0) { | ||
448 | return init_I2(0, lineHeight_Text(fontId)); | ||
449 | } | ||
450 | int advance; | ||
451 | run_Font_(&text_.fonts[fontId], measure_RunMode, text, n, zero_I2(), &advance); | ||
452 | return init_I2(advance, lineHeight_Text(fontId)); | ||
453 | } | ||
454 | |||
455 | static void draw_Text_(int fontId, iInt2 pos, int color, const char *text) { | ||
456 | iText *d = &text_; | ||
457 | const iColor clr = get_Color(color & mask_ColorId); | ||
458 | SDL_SetTextureColorMod(d->cache, clr.r, clr.g, clr.b); | ||
459 | run_Font_(&d->fonts[fontId], | ||
460 | color & permanent_ColorId ? drawPermanentColor_RunMode : draw_RunMode, | ||
461 | text, | ||
462 | iInvalidSize, | ||
463 | pos, | ||
464 | NULL); | ||
465 | } | ||
466 | |||
467 | void draw_Text(int fontId, iInt2 pos, int color, const char *text, ...) { | ||
468 | iBlock chars; | ||
469 | init_Block(&chars, 0); { | ||
470 | va_list args; | ||
471 | va_start(args, text); | ||
472 | vprintf_Block(&chars, text, args); | ||
473 | va_end(args); | ||
474 | } | ||
475 | if (pos.x < 0) { | ||
476 | /* Right-aligned. */ | ||
477 | pos.x = -pos.x - measure_Text(fontId, cstr_Block(&chars)).x; | ||
478 | } | ||
479 | if (pos.y < 0) { | ||
480 | /* Bottom-aligned. */ | ||
481 | pos.y = -pos.y - lineHeight_Text(fontId); | ||
482 | } | ||
483 | draw_Text_(fontId, pos, color, cstr_Block(&chars)); | ||
484 | deinit_Block(&chars); | ||
485 | } | ||
486 | |||
487 | void drawCentered_Text(int fontId, iRect rect, int color, const char *text, ...) { | ||
488 | iBlock chars; | ||
489 | init_Block(&chars, 0); { | ||
490 | va_list args; | ||
491 | va_start(args, text); | ||
492 | vprintf_Block(&chars, text, args); | ||
493 | va_end(args); | ||
494 | } | ||
495 | const iInt2 textSize = advance_Text(fontId, cstr_Block(&chars)); | ||
496 | draw_Text_(fontId, sub_I2(mid_Rect(rect), divi_I2(textSize, 2)), color, cstr_Block(&chars)); | ||
497 | deinit_Block(&chars); | ||
498 | } | ||
499 | |||
500 | SDL_Texture *glyphCache_Text(void) { | ||
501 | return text_.cache; | ||
502 | } | ||
503 | |||
504 | /*-----------------------------------------------------------------------------------------------*/ | ||
505 | |||
506 | iDefineTypeConstructionArgs(TextBuf, (int font, const char *text), font, text) | ||
507 | |||
508 | void init_TextBuf(iTextBuf *d, int font, const char *text) { | ||
509 | SDL_Renderer *render = text_.render; | ||
510 | d->size = advance_Text(font, text); | ||
511 | d->texture = SDL_CreateTexture(render, | ||
512 | SDL_PIXELFORMAT_RGBA8888, | ||
513 | SDL_TEXTUREACCESS_STATIC | SDL_TEXTUREACCESS_TARGET, | ||
514 | d->size.x, | ||
515 | d->size.y); | ||
516 | SDL_SetTextureBlendMode(d->texture, SDL_BLENDMODE_BLEND); | ||
517 | SDL_SetRenderTarget(render, d->texture); | ||
518 | draw_Text_(font, zero_I2(), white_ColorId, text); | ||
519 | SDL_SetRenderTarget(render, NULL); | ||
520 | } | ||
521 | |||
522 | void deinit_TextBuf(iTextBuf *d) { | ||
523 | SDL_DestroyTexture(d->texture); | ||
524 | } | ||
525 | |||
526 | void draw_TextBuf(const iTextBuf *d, iInt2 pos, int color) { | ||
527 | const iColor clr = get_Color(color); | ||
528 | SDL_SetTextureColorMod(d->texture, clr.r, clr.g, clr.b); | ||
529 | SDL_RenderCopy(text_.render, | ||
530 | d->texture, | ||
531 | &(SDL_Rect){ 0, 0, d->size.x, d->size.y }, | ||
532 | &(SDL_Rect){ pos.x, pos.y, d->size.x, d->size.y }); | ||
533 | } | ||
diff --git a/src/ui/text.h b/src/ui/text.h new file mode 100644 index 00000000..b689582e --- /dev/null +++ b/src/ui/text.h | |||
@@ -0,0 +1,52 @@ | |||
1 | #pragma once | ||
2 | |||
3 | #include <the_Foundation/rect.h> | ||
4 | #include <the_Foundation/string.h> | ||
5 | |||
6 | #include <SDL_render.h> | ||
7 | |||
8 | enum iFontId { | ||
9 | default_FontId, | ||
10 | uiShortcuts_FontId, | ||
11 | uiInput_FontId, | ||
12 | /* Document fonts: */ | ||
13 | paragraph_FontId, | ||
14 | firstParagraph_FontId, | ||
15 | preformatted_FontId, | ||
16 | quote_FontId, | ||
17 | header1_FontId, | ||
18 | header2_FontId, | ||
19 | header3_FontId, | ||
20 | max_FontId | ||
21 | }; | ||
22 | |||
23 | #define specialSymbol_Text 0x10 | ||
24 | |||
25 | enum iSpecialSymbol { | ||
26 | silence_SpecialSymbol, | ||
27 | }; | ||
28 | |||
29 | void init_Text (SDL_Renderer *); | ||
30 | void deinit_Text (void); | ||
31 | |||
32 | int lineHeight_Text (int font); | ||
33 | iInt2 measure_Text (int font, const char *text); | ||
34 | iInt2 advance_Text (int font, const char *text); | ||
35 | iInt2 advanceN_Text (int font, const char *text, size_t n); | ||
36 | |||
37 | void draw_Text (int font, iInt2 pos, int color, const char *text, ...); /* negative pos to switch alignment */ | ||
38 | void drawCentered_Text (int font, iRect rect, int color, const char *text, ...); | ||
39 | |||
40 | SDL_Texture * glyphCache_Text (void); | ||
41 | |||
42 | /*-----------------------------------------------------------------------------------------------*/ | ||
43 | |||
44 | iDeclareType(TextBuf) | ||
45 | iDeclareTypeConstructionArgs(TextBuf, int font, const char *text) | ||
46 | |||
47 | struct Impl_TextBuf { | ||
48 | SDL_Texture *texture; | ||
49 | iInt2 size; | ||
50 | }; | ||
51 | |||
52 | void draw_TextBuf (const iTextBuf *, iInt2 pos, int color); | ||
diff --git a/src/ui/util.c b/src/ui/util.c new file mode 100644 index 00000000..9487e004 --- /dev/null +++ b/src/ui/util.c | |||
@@ -0,0 +1,604 @@ | |||
1 | #include "util.h" | ||
2 | |||
3 | #include "app.h" | ||
4 | #include "color.h" | ||
5 | #include "command.h" | ||
6 | #include "labelwidget.h" | ||
7 | #include "inputwidget.h" | ||
8 | #include "widget.h" | ||
9 | #include "text.h" | ||
10 | #include "window.h" | ||
11 | |||
12 | #include <the_Foundation/math.h> | ||
13 | #include <the_Foundation/path.h> | ||
14 | |||
15 | iBool isCommand_UserEvent(const SDL_Event *d, const char *cmd) { | ||
16 | return d->type == SDL_USEREVENT && d->user.code == command_UserEventCode && | ||
17 | equal_Command(d->user.data1, cmd); | ||
18 | } | ||
19 | |||
20 | const char *command_UserEvent(const SDL_Event *d) { | ||
21 | if (d->type == SDL_USEREVENT && d->user.code == command_UserEventCode) { | ||
22 | return d->user.data1; | ||
23 | } | ||
24 | return ""; | ||
25 | } | ||
26 | |||
27 | int keyMods_Sym(int kmods) { | ||
28 | kmods &= (KMOD_SHIFT | KMOD_ALT | KMOD_CTRL | KMOD_GUI); | ||
29 | /* Don't treat left/right modifiers differently. */ | ||
30 | if (kmods & KMOD_SHIFT) kmods |= KMOD_SHIFT; | ||
31 | if (kmods & KMOD_ALT) kmods |= KMOD_ALT; | ||
32 | if (kmods & KMOD_CTRL) kmods |= KMOD_CTRL; | ||
33 | if (kmods & KMOD_GUI) kmods |= KMOD_GUI; | ||
34 | return kmods; | ||
35 | } | ||
36 | |||
37 | /*-----------------------------------------------------------------------------------------------*/ | ||
38 | |||
39 | void init_Click(iClick *d, iAnyObject *widget, int button) { | ||
40 | d->isActive = iFalse; | ||
41 | d->button = button; | ||
42 | d->bounds = as_Widget(widget); | ||
43 | d->startPos = zero_I2(); | ||
44 | d->pos = zero_I2(); | ||
45 | } | ||
46 | |||
47 | enum iClickResult processEvent_Click(iClick *d, const SDL_Event *event) { | ||
48 | if (event->type == SDL_MOUSEMOTION) { | ||
49 | const iInt2 pos = init_I2(event->motion.x, event->motion.y); | ||
50 | if (d->isActive) { | ||
51 | d->pos = pos; | ||
52 | return drag_ClickResult; | ||
53 | } | ||
54 | } | ||
55 | if (event->type != SDL_MOUSEBUTTONDOWN && event->type != SDL_MOUSEBUTTONUP) { | ||
56 | return none_ClickResult; | ||
57 | } | ||
58 | const SDL_MouseButtonEvent *mb = &event->button; | ||
59 | if (mb->button != d->button) { | ||
60 | return none_ClickResult; | ||
61 | } | ||
62 | const iInt2 pos = init_I2(mb->x, mb->y); | ||
63 | if (event->type == SDL_MOUSEBUTTONDOWN && mb->clicks == 2) { | ||
64 | if (contains_Widget(d->bounds, pos)) { | ||
65 | d->pos = pos; | ||
66 | setMouseGrab_Widget(NULL); | ||
67 | return double_ClickResult; | ||
68 | } | ||
69 | } | ||
70 | if (!d->isActive) { | ||
71 | if (mb->state == SDL_PRESSED) { | ||
72 | if (contains_Widget(d->bounds, pos)) { | ||
73 | d->isActive = iTrue; | ||
74 | d->startPos = d->pos = pos; | ||
75 | //setFlags_Widget(d->bounds, hover_WidgetFlag, iFalse); | ||
76 | setMouseGrab_Widget(d->bounds); | ||
77 | return started_ClickResult; | ||
78 | } | ||
79 | } | ||
80 | } | ||
81 | else { /* Active. */ | ||
82 | if (mb->state == SDL_RELEASED) { | ||
83 | enum iClickResult result = contains_Widget(d->bounds, pos) | ||
84 | ? finished_ClickResult | ||
85 | : aborted_ClickResult; | ||
86 | d->isActive = iFalse; | ||
87 | d->pos = pos; | ||
88 | setMouseGrab_Widget(NULL); | ||
89 | return result; | ||
90 | } | ||
91 | } | ||
92 | return none_ClickResult; | ||
93 | } | ||
94 | |||
95 | void cancel_Click(iClick *d) { | ||
96 | if (d->isActive) { | ||
97 | d->isActive = iFalse; | ||
98 | setMouseGrab_Widget(NULL); | ||
99 | } | ||
100 | } | ||
101 | |||
102 | iBool isMoved_Click(const iClick *d) { | ||
103 | return dist_I2(d->startPos, d->pos) > 2; | ||
104 | } | ||
105 | |||
106 | iInt2 pos_Click(const iClick *d) { | ||
107 | return d->pos; | ||
108 | } | ||
109 | |||
110 | iRect rect_Click(const iClick *d) { | ||
111 | return initCorners_Rect(min_I2(d->startPos, d->pos), max_I2(d->startPos, d->pos)); | ||
112 | } | ||
113 | |||
114 | iInt2 delta_Click(const iClick *d) { | ||
115 | return sub_I2(d->pos, d->startPos); | ||
116 | } | ||
117 | |||
118 | /*-----------------------------------------------------------------------------------------------*/ | ||
119 | |||
120 | iWidget *makePadding_Widget(int size) { | ||
121 | iWidget *pad = new_Widget(); | ||
122 | setSize_Widget(pad, init1_I2(size)); | ||
123 | return pad; | ||
124 | } | ||
125 | |||
126 | iLabelWidget *makeHeading_Widget(const char *text) { | ||
127 | iLabelWidget *heading = new_LabelWidget(text, 0, 0, NULL); | ||
128 | setFlags_Widget(as_Widget(heading), frameless_WidgetFlag | fixedSize_WidgetFlag, iTrue); | ||
129 | return heading; | ||
130 | } | ||
131 | |||
132 | iWidget *makeVDiv_Widget(void) { | ||
133 | iWidget *div = new_Widget(); | ||
134 | setFlags_Widget(div, resizeChildren_WidgetFlag | arrangeVertical_WidgetFlag, iTrue); | ||
135 | return div; | ||
136 | } | ||
137 | |||
138 | iWidget *makeHDiv_Widget(void) { | ||
139 | iWidget *div = new_Widget(); | ||
140 | setFlags_Widget(div, resizeChildren_WidgetFlag | arrangeHorizontal_WidgetFlag, iTrue); | ||
141 | return div; | ||
142 | } | ||
143 | |||
144 | iWidget *addAction_Widget(iWidget *parent, int key, int kmods, const char *command) { | ||
145 | iLabelWidget *action = new_LabelWidget("", key, kmods, command); | ||
146 | setSize_Widget(as_Widget(action), zero_I2()); | ||
147 | addChildFlags_Widget(parent, iClob(action), hidden_WidgetFlag); | ||
148 | return as_Widget(action); | ||
149 | } | ||
150 | |||
151 | /*-----------------------------------------------------------------------------------------------*/ | ||
152 | |||
153 | static iBool menuHandler_(iWidget *menu, const char *cmd) { | ||
154 | if (isVisible_Widget(menu)) { | ||
155 | if (equal_Command(cmd, "menu.open") && pointer_Command(cmd) == menu->parent) { | ||
156 | /* Don't reopen self; instead, root will close the menu. */ | ||
157 | return iFalse; | ||
158 | } | ||
159 | if (!equal_Command(cmd, "window.resized")) { | ||
160 | closeMenu_Widget(menu); | ||
161 | } | ||
162 | } | ||
163 | return iFalse; | ||
164 | } | ||
165 | |||
166 | iWidget *makeMenu_Widget(iWidget *parent, const iMenuItem *items, size_t n) { | ||
167 | iWidget *menu = new_Widget(); | ||
168 | setBackgroundColor_Widget(menu, gray25_ColorId); | ||
169 | setFlags_Widget(menu, | ||
170 | keepOnTop_WidgetFlag | hidden_WidgetFlag | arrangeVertical_WidgetFlag | | ||
171 | arrangeSize_WidgetFlag | resizeChildrenToWidestChild_WidgetFlag, | ||
172 | iTrue); | ||
173 | for (size_t i = 0; i < n; ++i) { | ||
174 | const iMenuItem *item = &items[i]; | ||
175 | if (equal_CStr(item->label, "---")) { | ||
176 | iWidget *sep = addChild_Widget(menu, iClob(new_Widget())); | ||
177 | setBackgroundColor_Widget(sep, gray50_ColorId); | ||
178 | sep->rect.size.y = gap_UI / 3; | ||
179 | setFlags_Widget(sep, hover_WidgetFlag | fixedHeight_WidgetFlag, iTrue); | ||
180 | } | ||
181 | else { | ||
182 | iLabelWidget *label = addChildFlags_Widget( | ||
183 | menu, | ||
184 | iClob(new_LabelWidget(item->label, item->key, item->kmods, item->command)), | ||
185 | frameless_WidgetFlag | alignLeft_WidgetFlag | drawKey_WidgetFlag); | ||
186 | updateSize_LabelWidget(label); /* drawKey was set */ | ||
187 | } | ||
188 | } | ||
189 | addChild_Widget(parent, iClob(menu)); | ||
190 | setCommandHandler_Widget(menu, menuHandler_); | ||
191 | addAction_Widget(menu, SDLK_ESCAPE, 0, "cancel"); | ||
192 | return menu; | ||
193 | } | ||
194 | |||
195 | void openMenu_Widget(iWidget *d, iInt2 coord) { | ||
196 | /* Menu closes when commands are emitted, so handle any pending ones beforehand. */ | ||
197 | processEvents_App(); | ||
198 | setFlags_Widget(d, hidden_WidgetFlag, iFalse); | ||
199 | arrange_Widget(d); | ||
200 | d->rect.pos = coord; | ||
201 | /* Ensure the full menu is visible. */ | ||
202 | const iInt2 rootSize = rootSize_Window(get_Window()); | ||
203 | const int bottomExcess = bottom_Rect(bounds_Widget(d)) - rootSize.y; | ||
204 | if (bottomExcess > 0) { | ||
205 | d->rect.pos.y -= bottomExcess; | ||
206 | } | ||
207 | if (top_Rect(d->rect) < 0) { | ||
208 | d->rect.pos.y += -top_Rect(d->rect); | ||
209 | } | ||
210 | if (right_Rect(bounds_Widget(d)) > rootSize.x) { | ||
211 | d->rect.pos.x = coord.x - d->rect.size.x; | ||
212 | } | ||
213 | if (left_Rect(d->rect) < 0) { | ||
214 | d->rect.pos.x = 0; | ||
215 | } | ||
216 | } | ||
217 | |||
218 | void closeMenu_Widget(iWidget *d) { | ||
219 | setFlags_Widget(d, hidden_WidgetFlag, iTrue); | ||
220 | } | ||
221 | |||
222 | iLabelWidget *makeMenuButton_LabelWidget(const char *label, const iMenuItem *items, size_t n) { | ||
223 | iLabelWidget *button = new_LabelWidget(label, 0, 0, "menu.open"); | ||
224 | iWidget *menu = makeMenu_Widget(as_Widget(button), items, n); | ||
225 | setId_Widget(menu, "menu"); | ||
226 | return button; | ||
227 | } | ||
228 | |||
229 | /*-----------------------------------------------------------------------------------------------*/ | ||
230 | |||
231 | static iBool isTabPage_Widget_(const iWidget *tabs, const iWidget *page) { | ||
232 | return page->parent == findChild_Widget(tabs, "tabs.pages"); | ||
233 | } | ||
234 | |||
235 | static iBool tabSwitcher_(iWidget *tabs, const char *cmd) { | ||
236 | if (equal_Command(cmd, "tabs.switch")) { | ||
237 | iWidget *target = pointerLabel_Command(cmd, "page"); | ||
238 | if (!target) { | ||
239 | const iString *id = string_Command(cmd, "id"); | ||
240 | target = findChild_Widget(tabs, cstr_String(id)); | ||
241 | } | ||
242 | if (!target) return iFalse; | ||
243 | if (flags_Widget(target) & focusable_WidgetFlag) { | ||
244 | setFocus_Widget(target); | ||
245 | } | ||
246 | if (isTabPage_Widget_(tabs, target)) { | ||
247 | showTabPage_Widget(tabs, target); | ||
248 | return iTrue; | ||
249 | } | ||
250 | else if (hasParent_Widget(target, tabs)) { | ||
251 | /* Some widget on a page. */ | ||
252 | while (!isTabPage_Widget_(tabs, target)) { | ||
253 | target = target->parent; | ||
254 | } | ||
255 | showTabPage_Widget(tabs, target); | ||
256 | return iTrue; | ||
257 | } | ||
258 | } | ||
259 | else if (equal_Command(cmd, "tabs.next") || equal_Command(cmd, "tabs.prev")) { | ||
260 | iWidget *pages = findChild_Widget(tabs, "tabs.pages"); | ||
261 | int tabIndex = 0; | ||
262 | iConstForEach(ObjectList, i, pages->children) { | ||
263 | const iWidget *child = constAs_Widget(i.object); | ||
264 | if (isVisible_Widget(child)) break; | ||
265 | tabIndex++; | ||
266 | } | ||
267 | tabIndex += (equal_Command(cmd, "tabs.next") ? +1 : -1); | ||
268 | showTabPage_Widget(tabs, child_Widget(pages, iWrap(tabIndex, 0, childCount_Widget(pages)))); | ||
269 | return iTrue; | ||
270 | } | ||
271 | return iFalse; | ||
272 | } | ||
273 | |||
274 | iWidget *makeTabs_Widget(iWidget *parent) { | ||
275 | iWidget *tabs = makeVDiv_Widget(); | ||
276 | iWidget *buttons = addChild_Widget(tabs, iClob(new_Widget())); | ||
277 | setFlags_Widget(buttons, arrangeHorizontal_WidgetFlag | arrangeHeight_WidgetFlag, iTrue); | ||
278 | setId_Widget(buttons, "tabs.buttons"); | ||
279 | iWidget *pages = addChildFlags_Widget( | ||
280 | tabs, iClob(new_Widget()), expand_WidgetFlag | resizeChildren_WidgetFlag); | ||
281 | setId_Widget(pages, "tabs.pages"); | ||
282 | addChild_Widget(parent, iClob(tabs)); | ||
283 | setCommandHandler_Widget(tabs, tabSwitcher_); | ||
284 | return tabs; | ||
285 | } | ||
286 | |||
287 | static void addTabPage_Widget_(iWidget *tabs, enum iWidgetAddPos addPos, iWidget *page, | ||
288 | const char *label, int key, int kmods) { | ||
289 | iWidget * pages = findChild_Widget(tabs, "tabs.pages"); | ||
290 | const iBool isSel = childCount_Widget(pages) == 0; | ||
291 | iWidget * button = addChildPos_Widget( | ||
292 | findChild_Widget(tabs, "tabs.buttons"), | ||
293 | iClob(new_LabelWidget(label, key, kmods, cstrFormat_String("tabs.switch page:%p", page))), | ||
294 | addPos); | ||
295 | setFlags_Widget(button, selected_WidgetFlag, isSel); | ||
296 | addChildPos_Widget(pages, page, addPos); | ||
297 | setFlags_Widget(page, hidden_WidgetFlag | disabled_WidgetFlag, !isSel); | ||
298 | } | ||
299 | |||
300 | void appendTabPage_Widget(iWidget *tabs, iWidget *page, const char *label, int key, int kmods) { | ||
301 | addTabPage_Widget_(tabs, back_WidgetAddPos, page, label, key, kmods); | ||
302 | } | ||
303 | |||
304 | void prependTabPage_Widget(iWidget *tabs, iWidget *page, const char *label, int key, int kmods) { | ||
305 | addTabPage_Widget_(tabs, front_WidgetAddPos, page, label, key, kmods); | ||
306 | } | ||
307 | |||
308 | iWidget *tabPage_Widget(iWidget *tabs, size_t index) { | ||
309 | iWidget *pages = findChild_Widget(tabs, "tabs.pages"); | ||
310 | return child_Widget(pages, index); | ||
311 | } | ||
312 | |||
313 | iWidget *removeTabPage_Widget(iWidget *tabs, size_t index) { | ||
314 | iWidget *buttons = findChild_Widget(tabs, "tabs.buttons"); | ||
315 | iWidget *pages = findChild_Widget(tabs, "tabs.pages"); | ||
316 | iWidget *button = removeChild_Widget(buttons, child_Widget(buttons, index)); | ||
317 | iRelease(button); | ||
318 | iWidget *page = child_Widget(pages, index); | ||
319 | ref_Object(page); | ||
320 | setFlags_Widget(page, hidden_WidgetFlag | disabled_WidgetFlag, iFalse); | ||
321 | removeChild_Widget(pages, page); | ||
322 | return page; | ||
323 | } | ||
324 | |||
325 | void showTabPage_Widget(iWidget *tabs, const iWidget *page) { | ||
326 | /* Select the corresponding button. */ { | ||
327 | iWidget *buttons = findChild_Widget(tabs, "tabs.buttons"); | ||
328 | iForEach(ObjectList, i, buttons->children) { | ||
329 | iAssert(isInstance_Object(i.object, &Class_LabelWidget)); | ||
330 | iAny *label = i.object; | ||
331 | const iBool isSel = | ||
332 | (pointerLabel_Command(cstr_String(command_LabelWidget(label)), "page") == page); | ||
333 | setFlags_Widget(label, selected_WidgetFlag, isSel); | ||
334 | } | ||
335 | } | ||
336 | /* Show/hide pages. */ { | ||
337 | iWidget *pages = findChild_Widget(tabs, "tabs.pages"); | ||
338 | iForEach(ObjectList, i, pages->children) { | ||
339 | iWidget *child = as_Widget(i.object); | ||
340 | setFlags_Widget(child, hidden_WidgetFlag | disabled_WidgetFlag, child != page); | ||
341 | } | ||
342 | } | ||
343 | /* Notify. */ | ||
344 | if (!isEmpty_String(id_Widget(page))) { | ||
345 | postCommandf_App("tabs.changed id:%s", cstr_String(id_Widget(page))); | ||
346 | } | ||
347 | } | ||
348 | |||
349 | const iWidget *currentTabPage_Widget(const iWidget *tabs) { | ||
350 | iWidget *pages = findChild_Widget(tabs, "tabs.pages"); | ||
351 | iConstForEach(ObjectList, i, pages->children) { | ||
352 | if (isVisible_Widget(constAs_Widget(i.object))) { | ||
353 | return constAs_Widget(i.object); | ||
354 | } | ||
355 | } | ||
356 | return NULL; | ||
357 | } | ||
358 | |||
359 | size_t tabCount_Widget(const iWidget *tabs) { | ||
360 | return childCount_Widget(findChild_Widget(tabs, "tabs.buttons")); | ||
361 | } | ||
362 | |||
363 | /*-----------------------------------------------------------------------------------------------*/ | ||
364 | |||
365 | static void acceptFilePath_(iWidget *dlg) { | ||
366 | iInputWidget *input = findChild_Widget(dlg, "input"); | ||
367 | iString *path = makeAbsolute_Path(text_InputWidget(input)); | ||
368 | postCommandf_App("%s path:%s", cstr_String(id_Widget(dlg)), cstr_String(path)); | ||
369 | destroy_Widget(dlg); | ||
370 | delete_String(path); | ||
371 | } | ||
372 | |||
373 | iBool filePathHandler_(iWidget *dlg, const char *cmd) { | ||
374 | iWidget *ptr = as_Widget(pointer_Command(cmd)); | ||
375 | if (equal_Command(cmd, "input.ended")) { | ||
376 | if (hasParent_Widget(ptr, dlg)) { | ||
377 | if (arg_Command(cmd)) { | ||
378 | acceptFilePath_(dlg); | ||
379 | } | ||
380 | else { | ||
381 | destroy_Widget(dlg); | ||
382 | } | ||
383 | return iTrue; | ||
384 | } | ||
385 | return iFalse; | ||
386 | } | ||
387 | else if (ptr && !hasParent_Widget(ptr, dlg)) { | ||
388 | /* Command from outside the dialog, so dismiss the dialog. */ | ||
389 | if (!equal_Command(cmd, "focus.lost")) { | ||
390 | destroy_Widget(dlg); | ||
391 | } | ||
392 | return iFalse; | ||
393 | } | ||
394 | else if (equal_Command(cmd, "filepath.cancel")) { | ||
395 | end_InputWidget(findChild_Widget(dlg, "input"), iFalse); | ||
396 | destroy_Widget(dlg); | ||
397 | return iTrue; | ||
398 | } | ||
399 | else if (equal_Command(cmd, "filepath.accept")) { | ||
400 | acceptFilePath_(dlg); | ||
401 | return iTrue; | ||
402 | } | ||
403 | return iFalse; | ||
404 | } | ||
405 | |||
406 | iWidget *makeSheet_Widget(const char *id) { | ||
407 | iWidget *sheet = new_Widget(); | ||
408 | setId_Widget(sheet, id); | ||
409 | setBackgroundColor_Widget(sheet, gray25_ColorId); | ||
410 | setFlags_Widget(sheet, | ||
411 | keepOnTop_WidgetFlag | arrangeVertical_WidgetFlag | | ||
412 | arrangeHeight_WidgetFlag, | ||
413 | iTrue); | ||
414 | const iInt2 rootSize = rootSize_Window(get_Window()); | ||
415 | setSize_Widget(sheet, init_I2(rootSize.x / 2, 0)); | ||
416 | setFlags_Widget(sheet, fixedHeight_WidgetFlag, iFalse); | ||
417 | return sheet; | ||
418 | } | ||
419 | |||
420 | void centerSheet_Widget(iWidget *sheet) { | ||
421 | arrange_Widget(sheet); | ||
422 | const iInt2 rootSize = rootSize_Window(get_Window()); | ||
423 | sheet->rect.pos.x = rootSize.x / 2 - sheet->rect.size.x / 2; | ||
424 | } | ||
425 | |||
426 | void makeFilePath_Widget(iWidget * parent, | ||
427 | const iString *initialPath, | ||
428 | const char * title, | ||
429 | const char * acceptLabel, | ||
430 | const char * command) { | ||
431 | setFocus_Widget(NULL); | ||
432 | processEvents_App(); | ||
433 | iWidget *dlg = makeSheet_Widget(command); | ||
434 | setCommandHandler_Widget(dlg, filePathHandler_); | ||
435 | addChild_Widget(parent, iClob(dlg)); | ||
436 | addChildFlags_Widget(dlg, iClob(new_LabelWidget(title, 0, 0, NULL)), frameless_WidgetFlag); | ||
437 | iInputWidget *input = addChild_Widget(dlg, iClob(new_InputWidget(0))); | ||
438 | if (initialPath) { | ||
439 | setText_InputWidget(input, collect_String(makeRelative_Path(initialPath))); | ||
440 | } | ||
441 | setId_Widget(as_Widget(input), "input"); | ||
442 | as_Widget(input)->rect.size.x = dlg->rect.size.x; | ||
443 | addChild_Widget(dlg, iClob(makePadding_Widget(gap_UI))); | ||
444 | iWidget *div = new_Widget(); { | ||
445 | setFlags_Widget(div, arrangeHorizontal_WidgetFlag | arrangeSize_WidgetFlag, iTrue); | ||
446 | addChild_Widget(div, iClob(new_LabelWidget("Cancel", SDLK_ESCAPE, 0, "filepath.cancel"))); | ||
447 | addChild_Widget(div, iClob(new_LabelWidget(acceptLabel, SDLK_RETURN, 0, "filepath.accept"))); | ||
448 | } | ||
449 | addChild_Widget(dlg, iClob(div)); | ||
450 | centerSheet_Widget(dlg); | ||
451 | setFocus_Widget(as_Widget(input)); | ||
452 | } | ||
453 | |||
454 | static void acceptValueInput_(iWidget *dlg) { | ||
455 | const iInputWidget *input = findChild_Widget(dlg, "input"); | ||
456 | const iString *val = text_InputWidget(input); | ||
457 | postCommandf_App("%s arg:%d value:%s", | ||
458 | cstr_String(id_Widget(dlg)), | ||
459 | toInt_String(val), | ||
460 | cstr_String(val)); | ||
461 | } | ||
462 | |||
463 | iBool valueInputHandler_(iWidget *dlg, const char *cmd) { | ||
464 | iWidget *ptr = as_Widget(pointer_Command(cmd)); | ||
465 | if (equal_Command(cmd, "input.ended")) { | ||
466 | if (hasParent_Widget(ptr, dlg)) { | ||
467 | if (arg_Command(cmd)) { | ||
468 | acceptValueInput_(dlg); | ||
469 | } | ||
470 | destroy_Widget(dlg); | ||
471 | return iTrue; | ||
472 | } | ||
473 | return iFalse; | ||
474 | } | ||
475 | else if (equal_Command(cmd, "cancel")) { | ||
476 | destroy_Widget(dlg); | ||
477 | return iTrue; | ||
478 | } | ||
479 | else if (equal_Command(cmd, "valueinput.accept")) { | ||
480 | acceptValueInput_(dlg); | ||
481 | destroy_Widget(dlg); | ||
482 | return iTrue; | ||
483 | } | ||
484 | return iFalse; | ||
485 | } | ||
486 | |||
487 | iWidget *makeValueInput_Widget(iWidget *parent, const iString *initialValue, const char *title, | ||
488 | const char *prompt, const char *command) { | ||
489 | setFocus_Widget(NULL); | ||
490 | processEvents_App(); | ||
491 | iWidget *dlg = makeSheet_Widget(command); | ||
492 | setCommandHandler_Widget(dlg, valueInputHandler_); | ||
493 | addChild_Widget(parent, iClob(dlg)); | ||
494 | addChild_Widget(dlg, iClob(new_LabelWidget(title, 0, 0, NULL))); | ||
495 | addChild_Widget(dlg, iClob(new_LabelWidget(prompt, 0, 0, NULL))); | ||
496 | iInputWidget *input = addChild_Widget(dlg, iClob(new_InputWidget(0))); | ||
497 | if (initialValue) { | ||
498 | setText_InputWidget(input, initialValue); | ||
499 | } | ||
500 | setId_Widget(as_Widget(input), "input"); | ||
501 | as_Widget(input)->rect.size.x = dlg->rect.size.x; | ||
502 | addChild_Widget(dlg, iClob(makePadding_Widget(gap_UI))); | ||
503 | iWidget *div = new_Widget(); { | ||
504 | setFlags_Widget(div, arrangeHorizontal_WidgetFlag | arrangeSize_WidgetFlag, iTrue); | ||
505 | addChild_Widget(div, iClob(new_LabelWidget("Cancel", SDLK_ESCAPE, 0, "cancel"))); | ||
506 | addChild_Widget(div, iClob(new_LabelWidget(cyan_ColorEscape "OK", SDLK_RETURN, 0, "valueinput.accept"))); | ||
507 | } | ||
508 | addChild_Widget(dlg, iClob(div)); | ||
509 | centerSheet_Widget(dlg); | ||
510 | setFocus_Widget(as_Widget(input)); | ||
511 | return dlg; | ||
512 | } | ||
513 | |||
514 | static iBool messageHandler_(iWidget *msg, const char *cmd) { | ||
515 | /* Any command dismisses the sheet. */ | ||
516 | iUnused(cmd); | ||
517 | destroy_Widget(msg); | ||
518 | return iFalse; | ||
519 | } | ||
520 | |||
521 | void makeMessage_Widget(const char *title, const char *msg) { | ||
522 | iWidget *dlg = makeQuestion_Widget( | ||
523 | title, msg, (const char *[]){ "Continue" }, (const char *[]){ "message.ok" }, 1); | ||
524 | addAction_Widget(dlg, SDLK_ESCAPE, 0, "message.ok"); | ||
525 | addAction_Widget(dlg, SDLK_SPACE, 0, "message.ok"); | ||
526 | } | ||
527 | |||
528 | iWidget *makeQuestion_Widget(const char *title, | ||
529 | const char *msg, | ||
530 | const char *labels[], | ||
531 | const char *commands[], | ||
532 | size_t count) { | ||
533 | processEvents_App(); | ||
534 | iWidget *dlg = makeSheet_Widget(""); | ||
535 | setCommandHandler_Widget(dlg, messageHandler_); | ||
536 | addChild_Widget(dlg, iClob(new_LabelWidget(title, 0, 0, NULL))); | ||
537 | addChild_Widget(dlg, iClob(new_LabelWidget(msg, 0, 0, NULL))); | ||
538 | addChild_Widget(dlg, iClob(makePadding_Widget(gap_UI))); | ||
539 | iWidget *div = new_Widget(); { | ||
540 | setFlags_Widget(div, arrangeHorizontal_WidgetFlag | arrangeSize_WidgetFlag, iTrue); | ||
541 | for (size_t i = 0; i < count; ++i) { | ||
542 | /* The last one is the default option. */ | ||
543 | const int key = (i == count - 1 ? SDLK_RETURN : 0); | ||
544 | addChild_Widget(div, iClob(new_LabelWidget(labels[i], key, 0, commands[i]))); | ||
545 | } | ||
546 | } | ||
547 | addChild_Widget(dlg, iClob(div)); | ||
548 | addChild_Widget(get_Window()->root, iClob(dlg)); | ||
549 | centerSheet_Widget(dlg); | ||
550 | return dlg; | ||
551 | } | ||
552 | |||
553 | void setToggle_Widget(iWidget *d, iBool active) { | ||
554 | setFlags_Widget(d, selected_WidgetFlag, active); | ||
555 | updateText_LabelWidget( | ||
556 | (iLabelWidget *) d, | ||
557 | collectNewFormat_String( | ||
558 | "%s", isSelected_Widget(d) ? "YES" : "NO")); | ||
559 | } | ||
560 | |||
561 | static iBool toggleHandler_(iWidget *d, const char *cmd) { | ||
562 | if (equal_Command(cmd, "toggle") && pointer_Command(cmd) == d) { | ||
563 | setToggle_Widget(d, (flags_Widget(d) & selected_WidgetFlag) == 0); | ||
564 | postCommand_Widget(d, | ||
565 | cstrFormat_String("%s.changed arg:%d", | ||
566 | cstr_String(id_Widget(d)), | ||
567 | isSelected_Widget(d) ? 1 : 0)); | ||
568 | return iTrue; | ||
569 | } | ||
570 | return iFalse; | ||
571 | } | ||
572 | |||
573 | iWidget *makeToggle_Widget(const char *id) { | ||
574 | iWidget *toggle = as_Widget(new_LabelWidget("YES", 0, 0, "toggle")); | ||
575 | setId_Widget(toggle, id); | ||
576 | setCommandHandler_Widget(toggle, toggleHandler_); | ||
577 | return toggle; | ||
578 | } | ||
579 | |||
580 | iWidget *makePreferences_Widget(void) { | ||
581 | iWidget *dlg = makeSheet_Widget("prefs"); | ||
582 | addChild_Widget(dlg, iClob(new_LabelWidget(cyan_ColorEscape "PREFERENCES", 0, 0, NULL))); | ||
583 | iWidget *page = new_Widget(); | ||
584 | addChild_Widget(dlg, iClob(page)); | ||
585 | setFlags_Widget(page, arrangeHorizontal_WidgetFlag | arrangeSize_WidgetFlag, iTrue); | ||
586 | iWidget *headings = addChildFlags_Widget( | ||
587 | page, iClob(new_Widget()), arrangeVertical_WidgetFlag | arrangeSize_WidgetFlag); | ||
588 | iWidget *values = addChildFlags_Widget( | ||
589 | page, iClob(new_Widget()), arrangeVertical_WidgetFlag | arrangeSize_WidgetFlag); | ||
590 | addChild_Widget(headings, iClob(makeHeading_Widget("Retain window size:"))); | ||
591 | addChild_Widget(values, iClob(makeToggle_Widget("prefs.retainwindow"))); | ||
592 | addChild_Widget(headings, iClob(makeHeading_Widget("UI scale factor:"))); | ||
593 | setId_Widget(addChild_Widget(values, iClob(new_InputWidget(8))), "prefs.uiscale"); | ||
594 | arrange_Widget(dlg); | ||
595 | // as_Widget(songDir)->rect.size.x = dlg->rect.size.x - headings->rect.size.x; | ||
596 | iWidget *div = new_Widget(); { | ||
597 | setFlags_Widget(div, arrangeHorizontal_WidgetFlag | arrangeSize_WidgetFlag, iTrue); | ||
598 | addChild_Widget(div, iClob(new_LabelWidget("Dismiss", SDLK_ESCAPE, 0, "prefs.dismiss"))); | ||
599 | } | ||
600 | addChild_Widget(dlg, iClob(div)); | ||
601 | addChild_Widget(get_Window()->root, iClob(dlg)); | ||
602 | centerSheet_Widget(dlg); | ||
603 | return dlg; | ||
604 | } | ||
diff --git a/src/ui/util.h b/src/ui/util.h new file mode 100644 index 00000000..04683a2f --- /dev/null +++ b/src/ui/util.h | |||
@@ -0,0 +1,110 @@ | |||
1 | #pragma once | ||
2 | |||
3 | #include <the_Foundation/rect.h> | ||
4 | #include <the_Foundation/vec2.h> | ||
5 | #include <SDL_events.h> | ||
6 | #include <ctype.h> | ||
7 | |||
8 | iDeclareType(Click) | ||
9 | iDeclareType(Widget) | ||
10 | iDeclareType(LabelWidget) | ||
11 | |||
12 | iBool isCommand_UserEvent (const SDL_Event *, const char *cmd); | ||
13 | const char * command_UserEvent (const SDL_Event *); | ||
14 | |||
15 | iLocalDef iBool isResize_UserEvent(const SDL_Event *d) { | ||
16 | return isCommand_UserEvent(d, "window.resized"); | ||
17 | } | ||
18 | |||
19 | #if defined (iPlatformApple) | ||
20 | # define KMOD_PRIMARY KMOD_GUI | ||
21 | # define KMOD_SECONDARY KMOD_CTRL | ||
22 | #else | ||
23 | # define KMOD_PRIMARY KMOD_CTRL | ||
24 | # define KMOD_SECONDARY KMOD_GUI | ||
25 | #endif | ||
26 | |||
27 | int keyMods_Sym (int kmods); /* shift, alt, control, or gui */ | ||
28 | |||
29 | /*-----------------------------------------------------------------------------------------------*/ | ||
30 | |||
31 | enum iClickResult { | ||
32 | none_ClickResult, | ||
33 | started_ClickResult, | ||
34 | drag_ClickResult, | ||
35 | finished_ClickResult, | ||
36 | aborted_ClickResult, | ||
37 | double_ClickResult, | ||
38 | }; | ||
39 | |||
40 | struct Impl_Click { | ||
41 | iBool isActive; | ||
42 | int button; | ||
43 | iWidget *bounds; | ||
44 | iInt2 startPos; | ||
45 | iInt2 pos; | ||
46 | }; | ||
47 | |||
48 | void init_Click (iClick *, iAnyObject *widget, int button); | ||
49 | enum iClickResult processEvent_Click (iClick *, const SDL_Event *event); | ||
50 | void cancel_Click (iClick *); | ||
51 | |||
52 | iBool isMoved_Click (const iClick *); | ||
53 | iInt2 pos_Click (const iClick *); | ||
54 | iRect rect_Click (const iClick *); | ||
55 | iInt2 delta_Click (const iClick *); | ||
56 | |||
57 | /*-----------------------------------------------------------------------------------------------*/ | ||
58 | |||
59 | iWidget * makePadding_Widget (int size); | ||
60 | iLabelWidget * makeHeading_Widget (const char *text); | ||
61 | iWidget * makeHDiv_Widget (void); | ||
62 | iWidget * makeVDiv_Widget (void); | ||
63 | iWidget * addAction_Widget (iWidget *parent, int key, int kmods, const char *command); | ||
64 | |||
65 | /*-----------------------------------------------------------------------------------------------*/ | ||
66 | |||
67 | iWidget * makeToggle_Widget (const char *id); | ||
68 | void setToggle_Widget (iWidget *toggle, iBool active); | ||
69 | |||
70 | /*-----------------------------------------------------------------------------------------------*/ | ||
71 | |||
72 | iDeclareType(MenuItem) | ||
73 | |||
74 | struct Impl_MenuItem { | ||
75 | const char *label; | ||
76 | int key; | ||
77 | int kmods; | ||
78 | const char *command; | ||
79 | }; | ||
80 | |||
81 | iWidget * makeMenu_Widget (iWidget *parent, const iMenuItem *items, size_t n); /* returns no ref */ | ||
82 | void openMenu_Widget (iWidget *, iInt2 coord); | ||
83 | void closeMenu_Widget (iWidget *); | ||
84 | |||
85 | iLabelWidget * makeMenuButton_LabelWidget (const char *label, const iMenuItem *items, size_t n); | ||
86 | |||
87 | /*-----------------------------------------------------------------------------------------------*/ | ||
88 | |||
89 | iWidget * makeTabs_Widget (iWidget *parent); | ||
90 | void appendTabPage_Widget (iWidget *tabs, iWidget *page, const char *label, int key, int kmods); | ||
91 | void prependTabPage_Widget (iWidget *tabs, iWidget *page, const char *label, int key, int kmods); | ||
92 | iWidget * tabPage_Widget (iWidget *tabs, size_t index); | ||
93 | iWidget * removeTabPage_Widget (iWidget *tabs, size_t index); /* returns the page */ | ||
94 | void showTabPage_Widget (iWidget *tabs, const iWidget *page); | ||
95 | const iWidget *currentTabPage_Widget(const iWidget *tabs); | ||
96 | size_t tabCount_Widget (const iWidget *tabs); | ||
97 | |||
98 | /*-----------------------------------------------------------------------------------------------*/ | ||
99 | |||
100 | iWidget * makeSheet_Widget (const char *id); | ||
101 | void centerSheet_Widget (iWidget *sheet); | ||
102 | |||
103 | void makeFilePath_Widget (iWidget *parent, const iString *initialPath, const char *title, | ||
104 | const char *acceptLabel, const char *command); | ||
105 | iWidget * makeValueInput_Widget (iWidget *parent, const iString *initialValue, const char *title, | ||
106 | const char *prompt, const char *command); | ||
107 | void makeMessage_Widget (const char *title, const char *msg); | ||
108 | iWidget * makeQuestion_Widget (const char *title, const char *msg, | ||
109 | const char *labels[], const char *commands[], size_t count); | ||
110 | iWidget * makePreferences_Widget (void); | ||
diff --git a/src/ui/widget.c b/src/ui/widget.c new file mode 100644 index 00000000..49fcd7c0 --- /dev/null +++ b/src/ui/widget.c | |||
@@ -0,0 +1,618 @@ | |||
1 | #include "widget.h" | ||
2 | |||
3 | #include "app.h" | ||
4 | #include "command.h" | ||
5 | #include "paint.h" | ||
6 | #include "util.h" | ||
7 | #include "window.h" | ||
8 | |||
9 | #include <the_Foundation/ptrset.h> | ||
10 | #include <SDL_mouse.h> | ||
11 | #include <stdarg.h> | ||
12 | |||
13 | iDeclareType(RootData) | ||
14 | |||
15 | struct Impl_RootData { | ||
16 | iWidget *hover; | ||
17 | iWidget *mouseGrab; | ||
18 | iWidget *focus; | ||
19 | iPtrSet *onTop; | ||
20 | iPtrSet *pendingDestruction; | ||
21 | }; | ||
22 | |||
23 | static iRootData rootData_; | ||
24 | |||
25 | iPtrSet *onTop_RootData_(void) { | ||
26 | if (!rootData_.onTop) { | ||
27 | rootData_.onTop = new_PtrSet(); | ||
28 | } | ||
29 | return rootData_.onTop; | ||
30 | } | ||
31 | |||
32 | void destroyPending_Widget(void) { | ||
33 | iForEach(PtrSet, i, rootData_.pendingDestruction) { | ||
34 | iWidget *widget = *i.value; | ||
35 | remove_PtrSet(onTop_RootData_(), widget); | ||
36 | iRelease(removeChild_Widget(widget->parent, widget)); | ||
37 | remove_PtrSetIterator(&i); | ||
38 | } | ||
39 | } | ||
40 | |||
41 | iDefineObjectConstruction(Widget) | ||
42 | |||
43 | void init_Widget(iWidget *d) { | ||
44 | init_String(&d->id); | ||
45 | d->flags = 0; | ||
46 | d->rect = zero_Rect(); | ||
47 | d->bgColor = none_ColorId; | ||
48 | d->children = NULL; | ||
49 | d->parent = NULL; | ||
50 | d->commandHandler = NULL; | ||
51 | } | ||
52 | |||
53 | void deinit_Widget(iWidget *d) { | ||
54 | iReleasePtr(&d->children); | ||
55 | deinit_String(&d->id); | ||
56 | } | ||
57 | |||
58 | static void aboutToBeDestroyed_Widget_(iWidget *d) { | ||
59 | if (isFocused_Widget(d)) { | ||
60 | setFocus_Widget(NULL); | ||
61 | return; | ||
62 | } | ||
63 | if (isHover_Widget(d)) { | ||
64 | rootData_.hover = NULL; | ||
65 | } | ||
66 | iForEach(ObjectList, i, d->children) { | ||
67 | aboutToBeDestroyed_Widget_(as_Widget(i.object)); | ||
68 | } | ||
69 | } | ||
70 | |||
71 | void destroy_Widget(iWidget *d) { | ||
72 | aboutToBeDestroyed_Widget_(d); | ||
73 | if (!rootData_.pendingDestruction) { | ||
74 | rootData_.pendingDestruction = new_PtrSet(); | ||
75 | } | ||
76 | insert_PtrSet(rootData_.pendingDestruction, d); | ||
77 | } | ||
78 | |||
79 | void setId_Widget(iWidget *d, const char *id) { | ||
80 | setCStr_String(&d->id, id); | ||
81 | } | ||
82 | |||
83 | const iString *id_Widget(const iWidget *d) { | ||
84 | return &d->id; | ||
85 | } | ||
86 | |||
87 | int flags_Widget(const iWidget *d) { | ||
88 | return d->flags; | ||
89 | } | ||
90 | |||
91 | void setFlags_Widget(iWidget *d, int flags, iBool set) { | ||
92 | iChangeFlags(d->flags, flags, set); | ||
93 | if (flags & keepOnTop_WidgetFlag) { | ||
94 | if (set) { | ||
95 | insert_PtrSet(onTop_RootData_(), d); | ||
96 | } | ||
97 | else { | ||
98 | remove_PtrSet(onTop_RootData_(), d); | ||
99 | } | ||
100 | } | ||
101 | } | ||
102 | |||
103 | void setPos_Widget(iWidget *d, iInt2 pos) { | ||
104 | d->rect.pos = pos; | ||
105 | } | ||
106 | |||
107 | void setSize_Widget(iWidget *d, iInt2 size) { | ||
108 | d->rect.size = size; | ||
109 | setFlags_Widget(d, fixedSize_WidgetFlag, iTrue); | ||
110 | } | ||
111 | |||
112 | void setBackgroundColor_Widget(iWidget *d, int bgColor) { | ||
113 | d->bgColor = bgColor; | ||
114 | } | ||
115 | |||
116 | void setCommandHandler_Widget(iWidget *d, iBool (*handler)(iWidget *, const char *)) { | ||
117 | d->commandHandler = handler; | ||
118 | } | ||
119 | |||
120 | static int numExpandingChildren_Widget_(const iWidget *d) { | ||
121 | int count = 0; | ||
122 | iConstForEach(ObjectList, i, d->children) { | ||
123 | const iWidget *child = constAs_Widget(i.object); | ||
124 | if (flags_Widget(child) & expand_WidgetFlag) { | ||
125 | count++; | ||
126 | } | ||
127 | } | ||
128 | return count; | ||
129 | } | ||
130 | |||
131 | static int widestChild_Widget_(const iWidget *d) { | ||
132 | int width = 0; | ||
133 | iConstForEach(ObjectList, i, d->children) { | ||
134 | const iWidget *child = constAs_Widget(i.object); | ||
135 | width = iMax(width, child->rect.size.x); | ||
136 | } | ||
137 | return width; | ||
138 | } | ||
139 | |||
140 | static void setWidth_Widget_(iWidget *d, int width) { | ||
141 | if (~d->flags & fixedWidth_WidgetFlag) { | ||
142 | d->rect.size.x = width; | ||
143 | } | ||
144 | } | ||
145 | |||
146 | static void setHeight_Widget_(iWidget *d, int height) { | ||
147 | if (~d->flags & fixedHeight_WidgetFlag) { | ||
148 | d->rect.size.y = height; | ||
149 | } | ||
150 | } | ||
151 | |||
152 | void arrange_Widget(iWidget *d) { | ||
153 | if (d->flags & resizeToParentWidth_WidgetFlag) { | ||
154 | setWidth_Widget_(d, d->parent->rect.size.x); | ||
155 | } | ||
156 | if (d->flags & resizeToParentHeight_WidgetFlag) { | ||
157 | setHeight_Widget_(d, d->parent->rect.size.y); | ||
158 | } | ||
159 | /* The rest of the arrangement depends on child widgets. */ | ||
160 | if (!d->children) { | ||
161 | return; | ||
162 | } | ||
163 | /* Resize children to fill the parent widget. */ | ||
164 | const size_t childCount = size_ObjectList(d->children); | ||
165 | if (d->flags & resizeChildren_WidgetFlag) { | ||
166 | const int expCount = numExpandingChildren_Widget_(d); | ||
167 | /* Only resize the expanding children, not touching the others. */ | ||
168 | if (expCount > 0) { | ||
169 | iInt2 avail = d->rect.size; | ||
170 | iConstForEach(ObjectList, i, d->children) { | ||
171 | const iWidget *child = constAs_Widget(i.object); | ||
172 | if (~child->flags & expand_WidgetFlag) { | ||
173 | subv_I2(&avail, child->rect.size); | ||
174 | } | ||
175 | } | ||
176 | avail = divi_I2(avail, expCount); | ||
177 | iForEach(ObjectList, j, d->children) { | ||
178 | iWidget *child = as_Widget(j.object); | ||
179 | if (child->flags & expand_WidgetFlag) { | ||
180 | if (d->flags & arrangeHorizontal_WidgetFlag) { | ||
181 | setWidth_Widget_(child, avail.x); | ||
182 | setHeight_Widget_(child, d->rect.size.y); | ||
183 | } | ||
184 | else if (d->flags & arrangeVertical_WidgetFlag) { | ||
185 | setWidth_Widget_(child, d->rect.size.x); | ||
186 | setHeight_Widget_(child, avail.y); | ||
187 | } | ||
188 | } | ||
189 | else { | ||
190 | /* Fill the off axis, though. */ | ||
191 | if (d->flags & arrangeHorizontal_WidgetFlag) { | ||
192 | setHeight_Widget_(child, d->rect.size.y); | ||
193 | } | ||
194 | else if (d->flags & arrangeVertical_WidgetFlag) { | ||
195 | setWidth_Widget_(child, d->rect.size.x); | ||
196 | } | ||
197 | } | ||
198 | } | ||
199 | } | ||
200 | else { | ||
201 | /* Evenly size all children. */ | ||
202 | iInt2 childSize = d->rect.size; | ||
203 | if (d->flags & arrangeHorizontal_WidgetFlag) { | ||
204 | childSize.x /= childCount; | ||
205 | } | ||
206 | else if (d->flags & arrangeVertical_WidgetFlag) { | ||
207 | childSize.y /= childCount; | ||
208 | } | ||
209 | iForEach(ObjectList, i, d->children) { | ||
210 | iWidget *child = as_Widget(i.object); | ||
211 | setWidth_Widget_(child, childSize.x); | ||
212 | setHeight_Widget_(child, childSize.y); | ||
213 | } | ||
214 | } | ||
215 | } | ||
216 | if (d->flags & resizeChildrenToWidestChild_WidgetFlag) { | ||
217 | const int widest = widestChild_Widget_(d); | ||
218 | iForEach(ObjectList, i, d->children) { | ||
219 | setWidth_Widget_(as_Widget(i.object), widest); | ||
220 | } | ||
221 | } | ||
222 | iInt2 pos = zero_I2(); | ||
223 | iForEach(ObjectList, i, d->children) { | ||
224 | iWidget *child = as_Widget(i.object); | ||
225 | arrange_Widget(child); | ||
226 | if (d->flags & (arrangeHorizontal_WidgetFlag | arrangeVertical_WidgetFlag)) { | ||
227 | child->rect.pos = pos; | ||
228 | if (d->flags & arrangeHorizontal_WidgetFlag) { | ||
229 | pos.x += child->rect.size.x; | ||
230 | } | ||
231 | else { | ||
232 | pos.y += child->rect.size.y; | ||
233 | } | ||
234 | } | ||
235 | } | ||
236 | /* Update the size of the widget according to the arrangement. */ | ||
237 | if (d->flags & arrangeSize_WidgetFlag) { | ||
238 | iRect bounds = zero_Rect(); | ||
239 | iConstForEach(ObjectList, i, d->children) { | ||
240 | const iWidget *child = constAs_Widget(i.object); | ||
241 | if (isEmpty_Rect(bounds)) { | ||
242 | bounds = child->rect; | ||
243 | } | ||
244 | else { | ||
245 | bounds = union_Rect(bounds, child->rect); | ||
246 | } | ||
247 | } | ||
248 | if (d->flags & arrangeWidth_WidgetFlag) { | ||
249 | setWidth_Widget_(d, bounds.size.x); | ||
250 | /* Parent size changed, must update the children.*/ | ||
251 | iForEach(ObjectList, j, d->children) { | ||
252 | iWidget *child = as_Widget(j.object); | ||
253 | if (child->flags & resizeToParentWidth_WidgetFlag) { | ||
254 | arrange_Widget(child); | ||
255 | } | ||
256 | } | ||
257 | } | ||
258 | if (d->flags & arrangeHeight_WidgetFlag) { | ||
259 | setHeight_Widget_(d, bounds.size.y); | ||
260 | /* Parent size changed, must update the children.*/ | ||
261 | iForEach(ObjectList, j, d->children) { | ||
262 | iWidget *child = as_Widget(j.object); | ||
263 | if (child->flags & resizeToParentHeight_WidgetFlag) { | ||
264 | arrange_Widget(child); | ||
265 | } | ||
266 | } | ||
267 | } | ||
268 | } | ||
269 | } | ||
270 | |||
271 | iRect bounds_Widget(const iWidget *d) { | ||
272 | iRect bounds = d->rect; | ||
273 | for (const iWidget *w = d->parent; w; w = w->parent) { | ||
274 | addv_I2(&bounds.pos, w->rect.pos); | ||
275 | } | ||
276 | return bounds; | ||
277 | } | ||
278 | |||
279 | iInt2 localCoord_Widget(const iWidget *d, iInt2 coord) { | ||
280 | for (const iWidget *w = d; w; w = w->parent) { | ||
281 | subv_I2(&coord, w->rect.pos); | ||
282 | } | ||
283 | return coord; | ||
284 | } | ||
285 | |||
286 | iBool contains_Widget(const iWidget *d, iInt2 coord) { | ||
287 | const iRect bounds = { zero_I2(), d->rect.size }; | ||
288 | return contains_Rect(bounds, localCoord_Widget(d, coord)); | ||
289 | } | ||
290 | |||
291 | iLocalDef iBool isKeyboardEvent_(const SDL_Event *ev) { | ||
292 | return (ev->type == SDL_KEYUP || ev->type == SDL_KEYDOWN || ev->type == SDL_TEXTINPUT); | ||
293 | } | ||
294 | |||
295 | iLocalDef iBool isMouseEvent_(const SDL_Event *ev) { | ||
296 | return (ev->type == SDL_MOUSEWHEEL || ev->type == SDL_MOUSEMOTION || | ||
297 | ev->type == SDL_MOUSEBUTTONUP || ev->type == SDL_MOUSEBUTTONDOWN); | ||
298 | } | ||
299 | |||
300 | static iBool filterEvent_Widget_(const iWidget *d, const SDL_Event *ev) { | ||
301 | const iBool isKey = isKeyboardEvent_(ev); | ||
302 | const iBool isMouse = isMouseEvent_(ev); | ||
303 | if (d->flags & disabled_WidgetFlag) { | ||
304 | if (isKey || isMouse) return iFalse; | ||
305 | } | ||
306 | if (d->flags & hidden_WidgetFlag) { | ||
307 | if (isMouse) return iFalse; | ||
308 | } | ||
309 | return iTrue; | ||
310 | } | ||
311 | |||
312 | void unhover_Widget(void) { | ||
313 | rootData_.hover = NULL; | ||
314 | } | ||
315 | |||
316 | iBool dispatchEvent_Widget(iWidget *d, const SDL_Event *ev) { | ||
317 | if (!d->parent) { | ||
318 | if (ev->type == SDL_MOUSEMOTION) { | ||
319 | /* Hover widget may change. */ | ||
320 | rootData_.hover = NULL; | ||
321 | } | ||
322 | if (rootData_.focus && isKeyboardEvent_(ev)) { | ||
323 | /* Root dispatches keyboard events directly to the focused widget. */ | ||
324 | if (dispatchEvent_Widget(rootData_.focus, ev)) { | ||
325 | return iTrue; | ||
326 | } | ||
327 | } | ||
328 | /* Root offers events first to widgets on top. */ | ||
329 | iForEach(PtrSet, i, rootData_.onTop) { | ||
330 | iWidget *widget = *i.value; | ||
331 | if (isVisible_Widget(widget) && dispatchEvent_Widget(widget, ev)) { | ||
332 | return iTrue; | ||
333 | } | ||
334 | } | ||
335 | } | ||
336 | else if (ev->type == SDL_MOUSEMOTION && !rootData_.hover && | ||
337 | flags_Widget(d) & hover_WidgetFlag && ~flags_Widget(d) & hidden_WidgetFlag && | ||
338 | ~flags_Widget(d) & disabled_WidgetFlag) { | ||
339 | if (contains_Widget(d, init_I2(ev->motion.x, ev->motion.y))) { | ||
340 | rootData_.hover = d; | ||
341 | } | ||
342 | } | ||
343 | if (filterEvent_Widget_(d, ev)) { | ||
344 | /* Children may handle it first. Done in reverse so children drawn on top get to | ||
345 | handle the events first. */ | ||
346 | iReverseForEach(ObjectList, i, d->children) { | ||
347 | iWidget *child = as_Widget(i.object); | ||
348 | if (child == rootData_.focus && isKeyboardEvent_(ev)) { | ||
349 | continue; /* Already dispatched. */ | ||
350 | } | ||
351 | if (isVisible_Widget(child) && child->flags & keepOnTop_WidgetFlag) { | ||
352 | /* Already dispatched. */ | ||
353 | continue; | ||
354 | } | ||
355 | if (dispatchEvent_Widget(child, ev)) { | ||
356 | return iTrue; | ||
357 | } | ||
358 | } | ||
359 | if (class_Widget(d)->processEvent(d, ev)) { | ||
360 | return iTrue; | ||
361 | } | ||
362 | } | ||
363 | return iFalse; | ||
364 | } | ||
365 | |||
366 | iBool processEvent_Widget(iWidget *d, const SDL_Event *ev) { | ||
367 | if (ev->type == SDL_KEYDOWN) { | ||
368 | if (ev->key.keysym.sym == SDLK_TAB) { | ||
369 | setFocus_Widget(findFocusable_Widget(focus_Widget(), | ||
370 | ev->key.keysym.mod & KMOD_SHIFT | ||
371 | ? backward_WidgetFocusDir | ||
372 | : forward_WidgetFocusDir)); | ||
373 | return iTrue; | ||
374 | } | ||
375 | } | ||
376 | switch (ev->type) { | ||
377 | case SDL_USEREVENT: { | ||
378 | if (ev->user.code == command_UserEventCode && d->commandHandler && | ||
379 | d->commandHandler(d, ev->user.data1)) { | ||
380 | return iTrue; | ||
381 | } | ||
382 | break; | ||
383 | } | ||
384 | } | ||
385 | return iFalse; | ||
386 | } | ||
387 | |||
388 | void draw_Widget(const iWidget *d) { | ||
389 | if (d->flags & hidden_WidgetFlag) return; | ||
390 | if (d->bgColor >= 0) { | ||
391 | iPaint p; | ||
392 | init_Paint(&p); | ||
393 | fillRect_Paint(&p, bounds_Widget(d), d->bgColor); | ||
394 | } | ||
395 | iConstForEach(ObjectList, i, d->children) { | ||
396 | const iWidget *child = constAs_Widget(i.object); | ||
397 | if (~child->flags & keepOnTop_WidgetFlag && ~child->flags & hidden_WidgetFlag) { | ||
398 | class_Widget(child)->draw(child); | ||
399 | } | ||
400 | } | ||
401 | /* Root draws the on-top widgets on top of everything else. */ | ||
402 | if (!d->parent) { | ||
403 | iConstForEach(PtrSet, i, onTop_RootData_()) { | ||
404 | draw_Widget(*i.value); | ||
405 | } | ||
406 | } | ||
407 | } | ||
408 | |||
409 | iAny *addChild_Widget(iWidget *d, iAnyObject *child) { | ||
410 | return addChildPos_Widget(d, child, back_WidgetAddPos); | ||
411 | } | ||
412 | |||
413 | iAny *addChildPos_Widget(iWidget *d, iAnyObject *child, enum iWidgetAddPos addPos) { | ||
414 | iAssert(child); | ||
415 | iAssert(d != child); | ||
416 | iWidget *widget = as_Widget(child); | ||
417 | iAssert(!widget->parent); | ||
418 | if (!d->children) { | ||
419 | d->children = new_ObjectList(); | ||
420 | } | ||
421 | if (addPos == back_WidgetAddPos) { | ||
422 | pushBack_ObjectList(d->children, widget); /* ref */ | ||
423 | } | ||
424 | else { | ||
425 | pushFront_ObjectList(d->children, widget); /* ref */ | ||
426 | } | ||
427 | widget->parent = d; | ||
428 | return child; | ||
429 | } | ||
430 | |||
431 | iAny *addChildFlags_Widget(iWidget *d, iAnyObject *child, int childFlags) { | ||
432 | setFlags_Widget(child, childFlags, iTrue); | ||
433 | return addChild_Widget(d, child); | ||
434 | } | ||
435 | |||
436 | iAny *removeChild_Widget(iWidget *d, iAnyObject *child) { | ||
437 | ref_Object(child); | ||
438 | iBool found = iFalse; | ||
439 | iForEach(ObjectList, i, d->children) { | ||
440 | if (i.object == child) { | ||
441 | remove_ObjectListIterator(&i); | ||
442 | found = iTrue; | ||
443 | break; | ||
444 | } | ||
445 | } | ||
446 | iAssert(found); | ||
447 | ((iWidget *) child)->parent = NULL; | ||
448 | return child; | ||
449 | } | ||
450 | |||
451 | iAny *child_Widget(iWidget *d, size_t index) { | ||
452 | iForEach(ObjectList, i, d->children) { | ||
453 | if (index-- == 0) { | ||
454 | return i.object; | ||
455 | } | ||
456 | } | ||
457 | return NULL; | ||
458 | } | ||
459 | |||
460 | iAny *findChild_Widget(const iWidget *d, const char *id) { | ||
461 | if (cmp_String(id_Widget(d), id) == 0) { | ||
462 | return iConstCast(iAny *, d); | ||
463 | } | ||
464 | iConstForEach(ObjectList, i, d->children) { | ||
465 | iAny *found = findChild_Widget(constAs_Widget(i.object), id); | ||
466 | if (found) return found; | ||
467 | } | ||
468 | return NULL; | ||
469 | } | ||
470 | |||
471 | size_t childCount_Widget(const iWidget *d) { | ||
472 | if (!d->children) return 0; | ||
473 | return size_ObjectList(d->children); | ||
474 | } | ||
475 | |||
476 | iBool isVisible_Widget(const iWidget *d) { | ||
477 | for (const iWidget *w = d; w; w = w->parent) { | ||
478 | if (w->flags & hidden_WidgetFlag) { | ||
479 | return iFalse; | ||
480 | } | ||
481 | } | ||
482 | return iTrue; | ||
483 | } | ||
484 | |||
485 | iBool isDisabled_Widget(const iWidget *d) { | ||
486 | for (const iWidget *w = d; w; w = w->parent) { | ||
487 | if (w->flags & disabled_WidgetFlag) { | ||
488 | return iTrue; | ||
489 | } | ||
490 | } | ||
491 | return iFalse; | ||
492 | } | ||
493 | |||
494 | iBool isFocused_Widget(const iWidget *d) { | ||
495 | return rootData_.focus == d; | ||
496 | } | ||
497 | |||
498 | iBool isHover_Widget(const iWidget *d) { | ||
499 | return rootData_.hover == d; | ||
500 | } | ||
501 | |||
502 | iBool isSelected_Widget(const iWidget *d) { | ||
503 | return (d->flags & selected_WidgetFlag) != 0; | ||
504 | } | ||
505 | |||
506 | iBool isCommand_Widget(const iWidget *d, const SDL_Event *ev, const char *cmd) { | ||
507 | if (isCommand_UserEvent(ev, cmd)) { | ||
508 | const iWidget *src = pointer_Command(command_UserEvent(ev)); | ||
509 | iAssert(!src || strstr(ev->user.data1, " ptr:")); | ||
510 | return src == d || hasParent_Widget(src, d); | ||
511 | } | ||
512 | return iFalse; | ||
513 | } | ||
514 | |||
515 | iBool hasParent_Widget(const iWidget *d, const iWidget *someParent) { | ||
516 | if (d) { | ||
517 | for (const iWidget *w = d->parent; w; w = w->parent) { | ||
518 | if (w == someParent) return iTrue; | ||
519 | } | ||
520 | } | ||
521 | return iFalse; | ||
522 | } | ||
523 | |||
524 | void setFocus_Widget(iWidget *d) { | ||
525 | if (rootData_.focus != d) { | ||
526 | if (rootData_.focus) { | ||
527 | iAssert(!contains_PtrSet(rootData_.pendingDestruction, rootData_.focus)); | ||
528 | postCommand_Widget(rootData_.focus, "focus.lost"); | ||
529 | } | ||
530 | rootData_.focus = d; | ||
531 | if (d) { | ||
532 | iAssert(flags_Widget(d) & focusable_WidgetFlag); | ||
533 | postCommand_Widget(d, "focus.gained"); | ||
534 | } | ||
535 | } | ||
536 | } | ||
537 | |||
538 | iWidget *focus_Widget(void) { | ||
539 | return rootData_.focus; | ||
540 | } | ||
541 | |||
542 | iWidget *hover_Widget(void) { | ||
543 | return rootData_.hover; | ||
544 | } | ||
545 | |||
546 | static const iWidget *findFocusable_Widget_(const iWidget *d, const iWidget *startFrom, | ||
547 | iBool *getNext, enum iWidgetFocusDir focusDir) { | ||
548 | if (startFrom == d) { | ||
549 | *getNext = iTrue; | ||
550 | return NULL; | ||
551 | } | ||
552 | if ((d->flags & focusable_WidgetFlag) && isVisible_Widget(d) && !isDisabled_Widget(d) && | ||
553 | *getNext) { | ||
554 | return d; | ||
555 | } | ||
556 | if (focusDir == forward_WidgetFocusDir) { | ||
557 | iConstForEach(ObjectList, i, d->children) { | ||
558 | const iWidget *found = | ||
559 | findFocusable_Widget_(constAs_Widget(i.object), startFrom, getNext, focusDir); | ||
560 | if (found) return found; | ||
561 | } | ||
562 | } | ||
563 | else { | ||
564 | iReverseConstForEach(ObjectList, i, d->children) { | ||
565 | const iWidget *found = | ||
566 | findFocusable_Widget_(constAs_Widget(i.object), startFrom, getNext, focusDir); | ||
567 | if (found) return found; | ||
568 | } | ||
569 | } | ||
570 | return NULL; | ||
571 | } | ||
572 | |||
573 | iAny *findFocusable_Widget(const iWidget *startFrom, enum iWidgetFocusDir focusDir) { | ||
574 | iWidget *root = get_Window()->root; | ||
575 | iBool getNext = (startFrom ? iFalse : iTrue); | ||
576 | const iWidget *found = findFocusable_Widget_(root, startFrom, &getNext, focusDir); | ||
577 | if (!found && startFrom) { | ||
578 | getNext = iTrue; | ||
579 | found = findFocusable_Widget_(root, NULL, &getNext, focusDir); | ||
580 | } | ||
581 | return iConstCast(iWidget *, found); | ||
582 | } | ||
583 | |||
584 | void setMouseGrab_Widget(iWidget *d) { | ||
585 | if (rootData_.mouseGrab != d) { | ||
586 | rootData_.mouseGrab = d; | ||
587 | SDL_CaptureMouse(d != NULL); | ||
588 | } | ||
589 | } | ||
590 | |||
591 | iWidget *mouseGrab_Widget(void) { | ||
592 | return rootData_.mouseGrab; | ||
593 | } | ||
594 | |||
595 | void postCommand_Widget(const iWidget *d, const char *cmd, ...) { | ||
596 | iString str; | ||
597 | init_String(&str); { | ||
598 | va_list args; | ||
599 | va_start(args, cmd); | ||
600 | vprintf_Block(&str.chars, cmd, args); | ||
601 | va_end(args); | ||
602 | } | ||
603 | iBool isGlobal = iFalse; | ||
604 | if (*cstr_String(&str) == '!') { | ||
605 | isGlobal = iTrue; | ||
606 | remove_Block(&str.chars, 0, 1); | ||
607 | } | ||
608 | if (!isGlobal) { | ||
609 | appendFormat_String(&str, " ptr:%p", d); | ||
610 | } | ||
611 | postCommandString_App(&str); | ||
612 | deinit_String(&str); | ||
613 | } | ||
614 | |||
615 | iBeginDefineClass(Widget) | ||
616 | .processEvent = processEvent_Widget, | ||
617 | .draw = draw_Widget, | ||
618 | iEndDefineClass(Widget) | ||
diff --git a/src/ui/widget.h b/src/ui/widget.h new file mode 100644 index 00000000..bf5c22f1 --- /dev/null +++ b/src/ui/widget.h | |||
@@ -0,0 +1,131 @@ | |||
1 | #pragma once | ||
2 | |||
3 | /* Base class for UI widgets. */ | ||
4 | |||
5 | #include "metrics.h" | ||
6 | |||
7 | #include <the_Foundation/object.h> | ||
8 | #include <the_Foundation/objectlist.h> | ||
9 | #include <the_Foundation/rect.h> | ||
10 | #include <the_Foundation/string.h> | ||
11 | #include <SDL_events.h> | ||
12 | |||
13 | #define iDeclareWidgetClass(className) \ | ||
14 | iDeclareType(className); \ | ||
15 | typedef iWidgetClass i##className##Class; \ | ||
16 | extern i##className##Class Class_##className; | ||
17 | |||
18 | iDeclareType(Widget) | ||
19 | iBeginDeclareClass(Widget) | ||
20 | iBool (*processEvent) (iWidget *, const SDL_Event *); | ||
21 | void (*draw) (const iWidget *); | ||
22 | iEndDeclareClass(Widget) | ||
23 | |||
24 | enum iWidgetFlag { | ||
25 | hidden_WidgetFlag = iBit(1), | ||
26 | disabled_WidgetFlag = iBit(2), | ||
27 | hover_WidgetFlag = iBit(3), /* eligible for mouse hover */ | ||
28 | selected_WidgetFlag = iBit(4), | ||
29 | pressed_WidgetFlag = iBit(5), | ||
30 | alignLeft_WidgetFlag = iBit(6), | ||
31 | alignRight_WidgetFlag = iBit(7), | ||
32 | frameless_WidgetFlag = iBit(8), | ||
33 | drawKey_WidgetFlag = iBit(10), | ||
34 | focusable_WidgetFlag = iBit(11), | ||
35 | keepOnTop_WidgetFlag = iBit(12), /* gets events first; drawn last */ | ||
36 | arrangeHorizontal_WidgetFlag = iBit(17), /* arrange children horizontally */ | ||
37 | arrangeVertical_WidgetFlag = iBit(18), /* arrange children vertically */ | ||
38 | arrangeWidth_WidgetFlag = iBit(19), /* area of children becomes parent size */ | ||
39 | arrangeHeight_WidgetFlag = iBit(20), /* area of children becomes parent size */ | ||
40 | arrangeSize_WidgetFlag = arrangeWidth_WidgetFlag | arrangeHeight_WidgetFlag, | ||
41 | resizeChildren_WidgetFlag = iBit(21), /* resize children to fill parent size */ | ||
42 | expand_WidgetFlag = iBit(22), | ||
43 | fixedWidth_WidgetFlag = iBit(23), | ||
44 | fixedHeight_WidgetFlag = iBit(24), | ||
45 | fixedSize_WidgetFlag = fixedWidth_WidgetFlag | fixedHeight_WidgetFlag, | ||
46 | resizeChildrenToWidestChild_WidgetFlag = iBit(25), | ||
47 | resizeToParentWidth_WidgetFlag = iBit(26), | ||
48 | resizeToParentHeight_WidgetFlag = iBit(27), | ||
49 | }; | ||
50 | |||
51 | enum iWidgetAddPos { | ||
52 | back_WidgetAddPos, | ||
53 | front_WidgetAddPos, | ||
54 | }; | ||
55 | |||
56 | enum iWidgetFocusDir { | ||
57 | forward_WidgetFocusDir, | ||
58 | backward_WidgetFocusDir, | ||
59 | }; | ||
60 | |||
61 | struct Impl_Widget { | ||
62 | iObject object; | ||
63 | iString id; | ||
64 | int flags; | ||
65 | iRect rect; | ||
66 | int bgColor; | ||
67 | iObjectList *children; | ||
68 | iWidget * parent; | ||
69 | iBool (*commandHandler)(iWidget *, const char *); | ||
70 | }; | ||
71 | |||
72 | iDeclareObjectConstruction(Widget) | ||
73 | |||
74 | iLocalDef iWidget *as_Widget(iAnyObject *d) { | ||
75 | if (d) { | ||
76 | iAssertIsObject(d); | ||
77 | iAssert(isInstance_Object(d, &Class_Widget)); | ||
78 | } | ||
79 | return (iWidget *) d; | ||
80 | } | ||
81 | |||
82 | iLocalDef const iWidget *constAs_Widget(const iAnyObject *d) { | ||
83 | if (d) { | ||
84 | iAssertIsObject(d); | ||
85 | iAssert(isInstance_Object(d, &Class_Widget)); | ||
86 | } | ||
87 | return (const iWidget *) d; | ||
88 | } | ||
89 | |||
90 | void destroy_Widget (iWidget *); /* widget removed and deleted later */ | ||
91 | void destroyPending_Widget(void); | ||
92 | |||
93 | const iString *id_Widget (const iWidget *); | ||
94 | int flags_Widget (const iWidget *); | ||
95 | iRect bounds_Widget (const iWidget *); | ||
96 | iInt2 localCoord_Widget (const iWidget *, iInt2 coord); | ||
97 | iBool contains_Widget (const iWidget *, iInt2 coord); | ||
98 | iAny * findChild_Widget (const iWidget *, const char *id); | ||
99 | iAny * findFocusable_Widget(const iWidget *startFrom, enum iWidgetFocusDir focusDir); | ||
100 | size_t childCount_Widget (const iWidget *); | ||
101 | void draw_Widget (const iWidget *); | ||
102 | |||
103 | iBool isVisible_Widget (const iWidget *); | ||
104 | iBool isDisabled_Widget (const iWidget *); | ||
105 | iBool isFocused_Widget (const iWidget *); | ||
106 | iBool isHover_Widget (const iWidget *); | ||
107 | iBool isSelected_Widget (const iWidget *); | ||
108 | iBool isCommand_Widget (const iWidget *d, const SDL_Event *ev, const char *cmd); | ||
109 | iBool hasParent_Widget (const iWidget *d, const iWidget *someParent); | ||
110 | void setId_Widget (iWidget *, const char *id); | ||
111 | void setFlags_Widget (iWidget *, int flags, iBool set); | ||
112 | void setPos_Widget (iWidget *, iInt2 pos); | ||
113 | void setSize_Widget (iWidget *, iInt2 size); | ||
114 | void setBackgroundColor_Widget (iWidget *, int bgColor); | ||
115 | void setCommandHandler_Widget (iWidget *, iBool (*handler)(iWidget *, const char *)); | ||
116 | iAny * addChild_Widget (iWidget *, iAnyObject *child); /* holds a ref */ | ||
117 | iAny * addChildPos_Widget (iWidget *, iAnyObject *child, enum iWidgetAddPos addPos); | ||
118 | iAny * addChildFlags_Widget(iWidget *, iAnyObject *child, int childFlags); /* holds a ref */ | ||
119 | iAny * removeChild_Widget (iWidget *, iAnyObject *child); /* returns a ref */ | ||
120 | iAny * child_Widget (iWidget *, size_t index); /* O(n) */ | ||
121 | void arrange_Widget (iWidget *); | ||
122 | iBool dispatchEvent_Widget(iWidget *, const SDL_Event *); | ||
123 | iBool processEvent_Widget (iWidget *, const SDL_Event *); | ||
124 | void postCommand_Widget (const iWidget *, const char *cmd, ...); | ||
125 | |||
126 | void setFocus_Widget (iWidget *); | ||
127 | iWidget *focus_Widget (void); | ||
128 | iWidget *hover_Widget (void); | ||
129 | void unhover_Widget (void); | ||
130 | void setMouseGrab_Widget (iWidget *); | ||
131 | iWidget *mouseGrab_Widget (void); | ||
diff --git a/src/ui/window.c b/src/ui/window.c new file mode 100644 index 00000000..8b4226ef --- /dev/null +++ b/src/ui/window.c | |||
@@ -0,0 +1,441 @@ | |||
1 | #include "window.h" | ||
2 | |||
3 | #include "app.h" | ||
4 | #include "command.h" | ||
5 | #include "paint.h" | ||
6 | #include "text.h" | ||
7 | #include "util.h" | ||
8 | #include "labelwidget.h" | ||
9 | #include "inputwidget.h" | ||
10 | #include "embedded.h" | ||
11 | #if defined (iPlatformMsys) | ||
12 | # include "../win32.h" | ||
13 | #endif | ||
14 | #if defined (iPlatformApple) && !defined (iPlatformIOS) | ||
15 | # include "macos.h" | ||
16 | #endif | ||
17 | |||
18 | #include <the_Foundation/file.h> | ||
19 | #include <the_Foundation/path.h> | ||
20 | #include <SDL_hints.h> | ||
21 | #include <SDL_timer.h> | ||
22 | #include <SDL_syswm.h> | ||
23 | |||
24 | #define STB_IMAGE_IMPLEMENTATION | ||
25 | #include "stb_image.h" | ||
26 | |||
27 | static iWindow *theWindow_ = NULL; | ||
28 | |||
29 | #if defined (iPlatformApple) | ||
30 | static float initialUiScale_ = 1.0f; | ||
31 | #else | ||
32 | static float initialUiScale_ = 1.1f; | ||
33 | #endif | ||
34 | |||
35 | iDefineTypeConstruction(Window) | ||
36 | |||
37 | static iBool handleRootCommands_(iWidget *root, const char *cmd) { | ||
38 | iUnused(root); | ||
39 | if (equal_Command(cmd, "menu.open")) { | ||
40 | iWidget *button = pointer_Command(cmd); | ||
41 | iWidget *menu = findChild_Widget(button, "menu"); | ||
42 | iAssert(menu); | ||
43 | if (!isVisible_Widget(menu)) { | ||
44 | openMenu_Widget(menu, init_I2(0, button->rect.size.y)); | ||
45 | } | ||
46 | else { | ||
47 | closeMenu_Widget(menu); | ||
48 | } | ||
49 | return iTrue; | ||
50 | } | ||
51 | else if (handleCommand_App(cmd)) { | ||
52 | return iTrue; | ||
53 | } | ||
54 | return iFalse; | ||
55 | } | ||
56 | |||
57 | static const iMenuItem fileMenuItems[] = { | ||
58 | #if !defined (iPlatformApple) | ||
59 | { "Quit Lagrange", 'q', KMOD_PRIMARY, "quit" } | ||
60 | #endif | ||
61 | }; | ||
62 | |||
63 | static const iMenuItem editMenuItems[] = { | ||
64 | #if !defined (iPlatformApple) | ||
65 | { "Preferences...", SDLK_COMMA, KMOD_PRIMARY, "preferences" } | ||
66 | #endif | ||
67 | }; | ||
68 | |||
69 | static const iMenuItem viewMenuItems[] = { | ||
70 | }; | ||
71 | |||
72 | static void setupUserInterface_Window(iWindow *d) { | ||
73 | /* Children of root cover the entire window. */ | ||
74 | setFlags_Widget(d->root, resizeChildren_WidgetFlag, iTrue); | ||
75 | setCommandHandler_Widget(d->root, handleRootCommands_); | ||
76 | #if 0 | ||
77 | iWidget *mainDiv = makeHDiv_Widget(); | ||
78 | setId_Widget(mainDiv, "maindiv"); | ||
79 | addChild_Widget(d->root, iClob(mainDiv)); | ||
80 | |||
81 | iWidget *sidebar = makeVDiv_Widget(); | ||
82 | setFlags_Widget(sidebar, arrangeWidth_WidgetFlag, iTrue); | ||
83 | setId_Widget(sidebar, "sidebar"); | ||
84 | addChild_Widget(mainDiv, iClob(sidebar)); | ||
85 | |||
86 | /* Menus. */ { | ||
87 | #if defined (iPlatformApple) && !defined (iPlatformIOS) | ||
88 | /* Use the native menus. */ | ||
89 | insertMenuItems_MacOS("File", fileMenuItems, iElemCount(fileMenuItems)); | ||
90 | insertMenuItems_MacOS("Edit", editMenuItems, iElemCount(editMenuItems)); | ||
91 | insertMenuItems_MacOS("View", viewMenuItems, iElemCount(viewMenuItems)); | ||
92 | #else | ||
93 | iWidget *menubar = new_Widget(); | ||
94 | setBackgroundColor_Widget(menubar, gray25_ColorId); | ||
95 | setFlags_Widget(menubar, arrangeHorizontal_WidgetFlag | arrangeHeight_WidgetFlag, iTrue); | ||
96 | addChild_Widget(menubar, iClob(makeMenuButton_LabelWidget("File", fileMenuItems, iElemCount(fileMenuItems)))); | ||
97 | addChild_Widget(menubar, iClob(makeMenuButton_LabelWidget("Edit", editMenuItems, iElemCount(editMenuItems)))); | ||
98 | addChild_Widget(menubar, iClob(makeMenuButton_LabelWidget("View", viewMenuItems, iElemCount(viewMenuItems)))); | ||
99 | addChild_Widget(sidebar, iClob(menubar)); | ||
100 | #endif | ||
101 | } | ||
102 | /* Tracker info. */ { | ||
103 | iWidget *trackerInfo = addChild_Widget(sidebar, iClob(new_Widget())); | ||
104 | setId_Widget(trackerInfo, "trackerinfo"); | ||
105 | trackerInfo->rect.size.y = lineHeight_Text(default_FontId) + 2 * gap_UI; | ||
106 | setFlags_Widget(trackerInfo, arrangeHorizontal_WidgetFlag | resizeChildren_WidgetFlag, iTrue); | ||
107 | setId_Widget( | ||
108 | addChild_Widget(trackerInfo, iClob(new_LabelWidget("", 'p', KMOD_PRIMARY, "pattern.goto arg:-1"))), | ||
109 | "trackerinfo.current"); | ||
110 | iLabelWidget *dims = new_LabelWidget("", 'r', KMOD_PRIMARY | KMOD_ALT, "pattern.resize"); | ||
111 | setId_Widget(addChild_Widget(trackerInfo, iClob(dims)), "trackerinfo.dims"); | ||
112 | } | ||
113 | |||
114 | iLibraryWidget *lib = new_LibraryWidget(); | ||
115 | setId_Widget(as_Widget(lib), "library"); | ||
116 | addChildFlags_Widget(sidebar, iClob(lib), expand_WidgetFlag); | ||
117 | |||
118 | iPlaybackWidget *play = new_PlaybackWidget(); | ||
119 | setId_Widget(as_Widget(play), "playback"); | ||
120 | addChild_Widget(sidebar, iClob(play)); | ||
121 | |||
122 | iWidget *mainTabs = makeTabs_Widget(mainDiv); | ||
123 | setId_Widget(mainTabs, "maintabs"); | ||
124 | setFlags_Widget(mainTabs, expand_WidgetFlag, iTrue); | ||
125 | |||
126 | /* Optional sidebar on the right. */ | ||
127 | iWidget *sidebar2 = new_Widget(); | ||
128 | setId_Widget(addChild_Widget(mainDiv, iClob(sidebar2)), "sidebar2"); | ||
129 | setFlags_Widget( | ||
130 | sidebar2, fixedWidth_WidgetFlag | frameless_WidgetFlag | resizeChildren_WidgetFlag, iTrue); | ||
131 | |||
132 | /* Pattern sequence. */ { | ||
133 | iSequenceWidget *seq = new_SequenceWidget(); | ||
134 | appendTabPage_Widget(mainTabs, iClob(seq), "SEQUENCE", 0, 0); | ||
135 | } | ||
136 | /* Tracker. */ { | ||
137 | iTrackerWidget *tracker = new_TrackerWidget(); | ||
138 | appendTabPage_Widget(mainTabs, as_Widget(tracker), "PATTERN", 0, 0); | ||
139 | } | ||
140 | /* Voice editor. */ { | ||
141 | iWidget *voice = as_Widget(new_VoiceWidget()); | ||
142 | setId_Widget(voice, "voicelayers"); | ||
143 | appendTabPage_Widget(mainTabs, iClob(voice), "VOICE", '3', KMOD_PRIMARY); | ||
144 | } | ||
145 | /* Song information. */ { | ||
146 | iWidget *songPage = new_Widget(); | ||
147 | setId_Widget(songPage, "songinfo"); | ||
148 | setFlags_Widget(songPage, arrangeHorizontal_WidgetFlag, iTrue); | ||
149 | iWidget *headings = | ||
150 | addChildFlags_Widget(songPage, | ||
151 | iClob(new_Widget()), | ||
152 | resizeToParentHeight_WidgetFlag | resizeChildren_WidgetFlag | | ||
153 | arrangeVertical_WidgetFlag | arrangeWidth_WidgetFlag); | ||
154 | iWidget *values = addChildFlags_Widget( | ||
155 | songPage, iClob(new_Widget()), arrangeVertical_WidgetFlag | arrangeSize_WidgetFlag); | ||
156 | |||
157 | setId_Widget(addChild_Widget(headings, iClob(makePadding_Widget(2 * gap_UI))), "headings.padding"); | ||
158 | setId_Widget(addChild_Widget(values, iClob(makePadding_Widget(2 * gap_UI))), "values.padding"); | ||
159 | |||
160 | addChild_Widget(headings, iClob(makeHeading_Widget(cyan_ColorEscape "SONG PROPERTIES"))); | ||
161 | addChild_Widget(values, iClob(makeHeading_Widget(""))); | ||
162 | |||
163 | const int fieldWidth = advance_Text(monospace_FontId, "A").x * 40; | ||
164 | iWidget *field; | ||
165 | |||
166 | addChild_Widget(headings, iClob(makeHeading_Widget("Title:"))); | ||
167 | setId_Widget(field = addChild_Widget(values, iClob(new_InputWidget(0))), "info.title"); | ||
168 | field->rect.size.x = fieldWidth; | ||
169 | |||
170 | addChild_Widget(headings, iClob(makeHeading_Widget("Author:"))); | ||
171 | setId_Widget(field = addChild_Widget(values, iClob(new_InputWidget(0))), "info.author"); | ||
172 | field->rect.size.x = fieldWidth; | ||
173 | |||
174 | addChild_Widget(headings, iClob(makeHeading_Widget("Tempo:"))); | ||
175 | setId_Widget(addChild_Widget(values, iClob(new_InputWidget(3))), "info.tempo"); | ||
176 | |||
177 | addChild_Widget(headings, iClob(makeHeading_Widget("Events per Beat:"))); | ||
178 | setId_Widget(addChild_Widget(values, iClob(new_InputWidget(2))), "info.eventsperbeat"); | ||
179 | |||
180 | addChild_Widget(headings, iClob(makeHeading_Widget("Num of Tracks:"))); | ||
181 | setId_Widget(addChild_Widget(values, iClob(new_InputWidget(2))), "info.numtracks"); | ||
182 | |||
183 | addChild_Widget(headings, iClob(makePadding_Widget(2 * gap_UI))); | ||
184 | addChild_Widget(values, iClob(makePadding_Widget(2 * gap_UI))); | ||
185 | |||
186 | addChild_Widget(headings, iClob(makeHeading_Widget(cyan_ColorEscape "SONG METADATA"))); | ||
187 | addChild_Widget(values, iClob(makeHeading_Widget(""))); | ||
188 | |||
189 | addChild_Widget(headings, iClob(makeHeading_Widget("Duration:"))); | ||
190 | setId_Widget(addChildFlags_Widget(values, iClob(newEmpty_LabelWidget()), | ||
191 | alignLeft_WidgetFlag | frameless_WidgetFlag), | ||
192 | "info.duration"); | ||
193 | addChild_Widget(headings, iClob(makeHeading_Widget("Statistics:\n\n "))); | ||
194 | setId_Widget(addChildFlags_Widget(values, | ||
195 | iClob(newEmpty_LabelWidget()), | ||
196 | alignLeft_WidgetFlag | frameless_WidgetFlag), | ||
197 | "info.statistics"); | ||
198 | addChild_Widget(headings, iClob(makeHeading_Widget("Created on:"))); | ||
199 | setId_Widget(addChildFlags_Widget(values, | ||
200 | iClob(newEmpty_LabelWidget()), | ||
201 | alignLeft_WidgetFlag | frameless_WidgetFlag), | ||
202 | "info.created"); | ||
203 | |||
204 | addChild_Widget(headings, iClob(makeHeading_Widget("Last Modified on:"))); | ||
205 | setId_Widget(addChildFlags_Widget(values, | ||
206 | iClob(newEmpty_LabelWidget()), | ||
207 | alignLeft_WidgetFlag | frameless_WidgetFlag), | ||
208 | "info.lastmodified"); | ||
209 | /* App info in the bottom. */ { | ||
210 | addChildFlags_Widget(headings, iClob(new_Widget()), expand_WidgetFlag); | ||
211 | addChildFlags_Widget( | ||
212 | headings, | ||
213 | iClob(new_LabelWidget(gray50_ColorEscape "Version " BWH_APP_VERSION, 0, 0, NULL)), | ||
214 | frameless_WidgetFlag | alignLeft_WidgetFlag); | ||
215 | } | ||
216 | appendTabPage_Widget(mainTabs, iClob(songPage), "INFO", '4', KMOD_PRIMARY); | ||
217 | } | ||
218 | /* Application status. */ { | ||
219 | iWidget *status = addChildFlags_Widget(d->root, iClob(newEmpty_LabelWidget()), 0); | ||
220 | setFont_LabelWidget((iLabelWidget *) status, monospace_FontId); | ||
221 | setFlags_Widget(status, frameless_WidgetFlag | alignRight_WidgetFlag, iTrue); | ||
222 | setId_Widget(status, "status"); | ||
223 | } | ||
224 | #endif | ||
225 | /* Glboal keyboard shortcuts. */ { | ||
226 | // addAction_Widget(d->root, SDLK_LEFTBRACKET, KMOD_SHIFT | KMOD_PRIMARY, "tabs.prev"); | ||
227 | } | ||
228 | } | ||
229 | |||
230 | static void updateRootSize_Window_(iWindow *d) { | ||
231 | iInt2 *size = &d->root->rect.size; | ||
232 | SDL_GetRendererOutputSize(d->render, &size->x, &size->y); | ||
233 | arrange_Widget(d->root); | ||
234 | postCommandf_App("window.resized width:%d height:%d", size->x, size->y); | ||
235 | } | ||
236 | |||
237 | static float pixelRatio_Window_(const iWindow *d) { | ||
238 | int dx, x; | ||
239 | SDL_GetRendererOutputSize(d->render, &dx, NULL); | ||
240 | SDL_GetWindowSize(d->win, &x, NULL); | ||
241 | return (float) dx / (float) x; | ||
242 | } | ||
243 | |||
244 | void init_Window(iWindow *d) { | ||
245 | theWindow_ = d; | ||
246 | uint32_t flags = SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI; | ||
247 | #if defined (iPlatformApple) | ||
248 | SDL_SetHint(SDL_HINT_RENDER_DRIVER, "metal"); | ||
249 | #else | ||
250 | flags |= SDL_WINDOW_OPENGL; | ||
251 | #endif | ||
252 | SDL_SetHint(SDL_HINT_RENDER_VSYNC, "1"); | ||
253 | if (SDL_CreateWindowAndRenderer(800, 500, flags, &d->win, &d->render)) { | ||
254 | fprintf(stderr, "Error when creating window: %s\n", SDL_GetError()); | ||
255 | exit(-2); | ||
256 | } | ||
257 | SDL_SetWindowMinimumSize(d->win, 640, 480); | ||
258 | SDL_SetWindowTitle(d->win, "Lagrange"); | ||
259 | SDL_ShowWindow(d->win); | ||
260 | /* Some info. */ { | ||
261 | SDL_RendererInfo info; | ||
262 | SDL_GetRendererInfo(d->render, &info); | ||
263 | printf("[window] renderer: %s\n", info.name); | ||
264 | } | ||
265 | d->uiScale = initialUiScale_; | ||
266 | d->pixelRatio = pixelRatio_Window_(d); | ||
267 | setPixelRatio_Metrics(d->pixelRatio * d->uiScale); | ||
268 | #if defined (iPlatformMsys) | ||
269 | useExecutableIconResource_SDLWindow(d->win); | ||
270 | #endif | ||
271 | #if defined (iPlatformLinux) | ||
272 | /* Load the window icon. */ { | ||
273 | int w, h, num; | ||
274 | const iBlock *icon = &imageAppicon64_Embedded; | ||
275 | stbi_uc *pixels = stbi_load_from_memory(constData_Block(icon), | ||
276 | size_Block(icon), | ||
277 | &w, | ||
278 | &h, | ||
279 | &num, | ||
280 | STBI_rgb_alpha); | ||
281 | SDL_Surface *surf = | ||
282 | SDL_CreateRGBSurfaceWithFormatFrom(pixels, w, h, 32, 4 * w, SDL_PIXELFORMAT_RGBA32); | ||
283 | SDL_SetWindowIcon(d->win, surf); | ||
284 | SDL_FreeSurface(surf); | ||
285 | stbi_image_free(pixels); | ||
286 | } | ||
287 | #endif | ||
288 | d->root = new_Widget(); | ||
289 | d->presentTime = 0.0; | ||
290 | setId_Widget(d->root, "root"); | ||
291 | init_Text(d->render); | ||
292 | #if defined (iPlatformApple) && !defined (iPlatformIOS) | ||
293 | setupApplication_MacOS(); | ||
294 | #endif | ||
295 | setupUserInterface_Window(d); | ||
296 | updateRootSize_Window_(d); | ||
297 | } | ||
298 | |||
299 | void deinit_Window(iWindow *d) { | ||
300 | if (theWindow_ == d) { | ||
301 | theWindow_ = NULL; | ||
302 | } | ||
303 | iReleasePtr(&d->root); | ||
304 | deinit_Text(); | ||
305 | SDL_DestroyRenderer(d->render); | ||
306 | SDL_DestroyWindow(d->win); | ||
307 | } | ||
308 | |||
309 | SDL_Renderer *renderer_Window(const iWindow *d) { | ||
310 | return d->render; | ||
311 | } | ||
312 | |||
313 | static iBool handleWindowEvent_Window_(iWindow *d, const SDL_WindowEvent *ev) { | ||
314 | switch (ev->event) { | ||
315 | case SDL_WINDOWEVENT_RESIZED: | ||
316 | updateRootSize_Window_(d); | ||
317 | return iTrue; | ||
318 | case SDL_WINDOWEVENT_LEAVE: | ||
319 | unhover_Widget(); | ||
320 | return iTrue; | ||
321 | default: | ||
322 | break; | ||
323 | } | ||
324 | return iFalse; | ||
325 | } | ||
326 | |||
327 | iBool processEvent_Window(iWindow *d, const SDL_Event *ev) { | ||
328 | switch (ev->type) { | ||
329 | case SDL_WINDOWEVENT: { | ||
330 | return handleWindowEvent_Window_(d, &ev->window); | ||
331 | } | ||
332 | default: { | ||
333 | SDL_Event event = *ev; | ||
334 | /* Map mouse pointer coordinate to our coordinate system. */ | ||
335 | if (event.type == SDL_MOUSEMOTION) { | ||
336 | const iInt2 pos = coord_Window(d, event.motion.x, event.motion.y); | ||
337 | event.motion.x = pos.x; | ||
338 | event.motion.y = pos.y; | ||
339 | } | ||
340 | else if (event.type == SDL_MOUSEBUTTONUP || event.type == SDL_MOUSEBUTTONDOWN) { | ||
341 | const iInt2 pos = coord_Window(d, event.button.x, event.button.y); | ||
342 | event.button.x = pos.x; | ||
343 | event.button.y = pos.y; | ||
344 | } | ||
345 | iWidget *widget = d->root; | ||
346 | if (event.type == SDL_MOUSEMOTION || event.type == SDL_MOUSEWHEEL || | ||
347 | event.type == SDL_MOUSEBUTTONUP || event.type == SDL_MOUSEBUTTONDOWN) { | ||
348 | if (mouseGrab_Widget()) { | ||
349 | widget = mouseGrab_Widget(); | ||
350 | } | ||
351 | } | ||
352 | return dispatchEvent_Widget(widget, &event); | ||
353 | } | ||
354 | } | ||
355 | return iFalse; | ||
356 | } | ||
357 | |||
358 | static void waitPresent_Window_(iWindow *d) { | ||
359 | const double ticksPerFrame = 1000.0 / 30.0; | ||
360 | uint32_t nowTime = SDL_GetTicks(); | ||
361 | if (nowTime < d->presentTime) { | ||
362 | SDL_Delay((uint32_t) (d->presentTime - nowTime)); | ||
363 | nowTime = SDL_GetTicks(); | ||
364 | } | ||
365 | /* Now it is the presentation time. */ | ||
366 | /* Figure out the next time in the future. */ | ||
367 | if (d->presentTime <= nowTime) { | ||
368 | d->presentTime += ticksPerFrame * ((int) ((nowTime - d->presentTime) / ticksPerFrame) + 1); | ||
369 | } | ||
370 | else { | ||
371 | d->presentTime = nowTime; | ||
372 | } | ||
373 | } | ||
374 | |||
375 | void draw_Window(iWindow *d) { | ||
376 | /* Clear the window. */ | ||
377 | SDL_SetRenderDrawColor(d->render, 0, 0, 0, 255); | ||
378 | SDL_RenderClear(d->render); | ||
379 | /* Draw widgets. */ | ||
380 | d->frameTime = SDL_GetTicks(); | ||
381 | draw_Widget(d->root); | ||
382 | #if 0 | ||
383 | /* Text cache debugging. */ { | ||
384 | SDL_Texture *cache = glyphCache_Text(); | ||
385 | SDL_Rect rect = { 140, 60, 512, 512 }; | ||
386 | SDL_SetRenderDrawColor(d->render, 0, 0, 0, 255); | ||
387 | SDL_RenderFillRect(d->render, &rect); | ||
388 | SDL_RenderCopy(d->render, glyphCache_Text(), NULL, &rect); | ||
389 | } | ||
390 | #endif | ||
391 | waitPresent_Window_(d); | ||
392 | SDL_RenderPresent(d->render); | ||
393 | } | ||
394 | |||
395 | void resize_Window(iWindow *d, int w, int h) { | ||
396 | SDL_SetWindowSize(d->win, w, h); | ||
397 | updateRootSize_Window_(d); | ||
398 | } | ||
399 | |||
400 | void setUiScale_Window(iWindow *d, float uiScale) { | ||
401 | uiScale = iClamp(uiScale, 0.5f, 4.0f); | ||
402 | if (d) { | ||
403 | d->uiScale = uiScale; | ||
404 | #if 0 | ||
405 | deinit_Text(); | ||
406 | setPixelRatio_Metrics(d->pixelRatio * d->uiScale); | ||
407 | init_Text(d->render); | ||
408 | postCommand_App("metrics.changed"); | ||
409 | /* TODO: Dynamic UI metrics change. Widgets need to update themselves. */ | ||
410 | #endif | ||
411 | } | ||
412 | else { | ||
413 | initialUiScale_ = uiScale; | ||
414 | } | ||
415 | } | ||
416 | |||
417 | iInt2 rootSize_Window(const iWindow *d) { | ||
418 | return d->root->rect.size; | ||
419 | } | ||
420 | |||
421 | iInt2 coord_Window(const iWindow *d, int x, int y) { | ||
422 | return mulf_I2(init_I2(x, y), d->pixelRatio); | ||
423 | } | ||
424 | |||
425 | iInt2 mouseCoord_Window(const iWindow *d) { | ||
426 | int x, y; | ||
427 | SDL_GetMouseState(&x, &y); | ||
428 | return coord_Window(d, x, y); | ||
429 | } | ||
430 | |||
431 | float uiScale_Window(const iWindow *d) { | ||
432 | return d->uiScale; | ||
433 | } | ||
434 | |||
435 | uint32_t frameTime_Window(const iWindow *d) { | ||
436 | return d->frameTime; | ||
437 | } | ||
438 | |||
439 | iWindow *get_Window(void) { | ||
440 | return theWindow_; | ||
441 | } | ||
diff --git a/src/ui/window.h b/src/ui/window.h new file mode 100644 index 00000000..d0413af4 --- /dev/null +++ b/src/ui/window.h | |||
@@ -0,0 +1,34 @@ | |||
1 | #pragma once | ||
2 | |||
3 | #include "widget.h" | ||
4 | |||
5 | #include <the_Foundation/defs.h> | ||
6 | #include <SDL_events.h> | ||
7 | #include <SDL_render.h> | ||
8 | #include <SDL_video.h> | ||
9 | |||
10 | iDeclareType(Window) | ||
11 | iDeclareTypeConstruction(Window) | ||
12 | |||
13 | struct Impl_Window { | ||
14 | SDL_Window * win; | ||
15 | SDL_Renderer *render; | ||
16 | iWidget * root; | ||
17 | float pixelRatio; | ||
18 | float uiScale; | ||
19 | uint32_t frameTime; | ||
20 | double presentTime; | ||
21 | }; | ||
22 | |||
23 | iBool processEvent_Window (iWindow *, const SDL_Event *); | ||
24 | void draw_Window (iWindow *); | ||
25 | void resize_Window (iWindow *, int w, int h); | ||
26 | void setUiScale_Window (iWindow *, float uiScale); | ||
27 | |||
28 | iInt2 rootSize_Window (const iWindow *); | ||
29 | float uiScale_Window (const iWindow *); | ||
30 | iInt2 coord_Window (const iWindow *, int x, int y); | ||
31 | iInt2 mouseCoord_Window (const iWindow *); | ||
32 | uint32_t frameTime_Window (const iWindow *); | ||
33 | |||
34 | iWindow * get_Window (void); | ||
diff --git a/src/win32.c b/src/win32.c new file mode 100644 index 00000000..1cdcf34c --- /dev/null +++ b/src/win32.c | |||
@@ -0,0 +1,18 @@ | |||
1 | #include "win32.h" | ||
2 | #include <SDL_syswm.h> | ||
3 | |||
4 | #define WIN32_LEAN_AND_MEAN | ||
5 | #include <Windows.h> | ||
6 | |||
7 | void useExecutableIconResource_SDLWindow(SDL_Window *win) { | ||
8 | HINSTANCE handle = GetModuleHandle(NULL); | ||
9 | HICON icon = LoadIcon(handle, "IDI_ICON1"); | ||
10 | if (icon) { | ||
11 | SDL_SysWMinfo wmInfo; | ||
12 | SDL_VERSION(&wmInfo.version); | ||
13 | if (SDL_GetWindowWMInfo(win, &wmInfo)) { | ||
14 | HWND hwnd = wmInfo.info.win.window; | ||
15 | SetClassLongPtr(hwnd, -14 /*GCL_HICON*/, (LONG_PTR) icon); | ||
16 | } | ||
17 | } | ||
18 | } | ||
diff --git a/src/win32.h b/src/win32.h new file mode 100644 index 00000000..b223ea4d --- /dev/null +++ b/src/win32.h | |||
@@ -0,0 +1,4 @@ | |||
1 | #pragma once | ||
2 | #include <SDL_video.h> | ||
3 | |||
4 | void useExecutableIconResource_SDLWindow(SDL_Window *win); | ||