summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--Makefile20
-rw-r--r--cfgparse.c233
-rw-r--r--cfgparse.h58
-rw-r--r--config.h36
-rw-r--r--dr_flac.h12536
-rw-r--r--error.h8
-rw-r--r--font.c238
-rw-r--r--library.c135
-rw-r--r--library.h22
-rw-r--r--luigi.c87
-rw-r--r--luigi.h5931
-rw-r--r--main.c181
-rw-r--r--maths.h9
-rw-r--r--memory.c8
-rw-r--r--memory.h1
-rw-r--r--plat.c449
-rw-r--r--plat.h33
-rw-r--r--rcache.c467
-rw-r--r--rcache.h148
-rw-r--r--rect.c96
-rw-r--r--rect.h43
-rw-r--r--render.c380
-rw-r--r--render.h140
-rw-r--r--stb_image.h9
-rw-r--r--stb_rect_pack.h623
-rw-r--r--stb_truetype.h5077
-rw-r--r--std_printers.c56
-rw-r--r--ui.c152
-rw-r--r--ui.h41
29 files changed, 18883 insertions, 8334 deletions
diff --git a/Makefile b/Makefile
index 14527e7..761b428 100644
--- a/Makefile
+++ b/Makefile
@@ -5,24 +5,19 @@ cflags = -I./ -g $(includes) $(defines) \
lflags = -lX11 -lm
target = twinkplayer
includes =
-defines = -Dplat_x11 \
+defines = \
-Dplat_posix \
-Dplat_pulse \
-Dis64bit=1 \
-Dplat_x86 \
-DDEBUG
+luigi = luigi.o
sources = \
- cfgparse.c \
- font.c \
library.c \
main.c \
memory.c \
- plat.c \
- rcache.c \
- rect.c \
- render.c \
- ui.c
+ plat.c
objects = $(sources:%.c=%.o)
@@ -31,12 +26,15 @@ all: $(target)
$(objects): %.o : %.c
$(compiler) -MMD -MF $(basename $@).d $(cflags) -o $@ -c $<
-$(target): $(objects)
- $(linker) $(objects) -o $@ $(lflags)
+$(luigi): luigi.c
+ gcc -MMD -MF $(basename $@).d -DUI_LINUX -w -std=c11 -g -o $@ -c $<
+
+$(target): $(objects) $(luigi)
+ $(linker) $(objects) $(luigi) -o $@ $(lflags)
clean:
rm *.d
rm *.o
- rm $(target)
+ rm -f $(target)
-include $(sources:%.c=%.d)
diff --git a/cfgparse.c b/cfgparse.c
deleted file mode 100644
index 6d1668f..0000000
--- a/cfgparse.c
+++ /dev/null
@@ -1,233 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "cfgparse.h"
-
-static const char* next_line(const char* line) {
- const char* c;
- for (c = line; *c != '\n'; c++) {
- if (!*c) return 0;
- }
- return c + 1;
-}
-
-static int is_object(
- const char* line,
- const char** start,
- int* len
-) {
- const char* c;
- if (line[0] != '[') return 0;
- *start = line + 1;
- for (
- c = line, *len = 0;
- *c && *c != '\n';
- c++, *len = *len + 1
- ) if (*c == ']') {
- *len = *len - 1;
- return 1;
- }
- return 0;
-}
-
-static int is_iden(char c) {
- return
- (c >= 'a' && c <= 'z') ||
- (c >= 'A' && c <= 'Z') ||
- (c == '_');
-}
-
-static int is_prop(
- const char* line,
- const char** start,
- int* len
-) {
- const char* c;
- *start = line;
- for (
- c = line, *len = 0;
- *c && *c != '\n';
- c++, *len = *len + 1
- ) if (*c == ':') {
- *len = *len;
- return 1;
- } else if (!is_iden(*c)) return 0;
- return 0;
-}
-
-static void fill_prop_string(
- cfg_Prop* p,
- Arena* arena,
- const char* start,
- int len
-) {
- p->type = cfg_type_string;
- p->as.str = arena_alloc(arena, len + 1);
- memcpy(p->as.str, start, len);
- p->as.str[len] = 0;
-}
-
-static void fill_prop_number(
- cfg_Prop* p,
- const char* start,
- int len
-) {
- (void)len;
- p->type = cfg_type_int;
- p->as.num = (int)strtol(start, 0, 10);
-}
-
-static void fill_prop_bool(
- cfg_Prop* p,
- const char* start,
- int len
-) {
- (void)len;
- p->type = cfg_type_int;
- if (!memcmp("true", start, 4))
- p->as.num = 1;
- else
- p->as.num = 0;
-}
-
-static void fill_prop_data(
- cfg_Prop* p,
- Arena* arena,
- const char* start,
- int len
-) {
- int i, size;
- char s[3];
- s[2] = 0;
- size = len / 2;
- p->type = cfg_type_data;
- p->as.data.data = arena_alloc(arena, size);
- p->as.data.size = size;
- for (i = 0; i < size; i++) {
- s[0] = start[i * 2];
- s[1] = start[i * 2 + 1];
- sscanf(s, "%x", (unsigned*)&p->as.data.data[i]);
- }
-}
-
-static void fill_prop_val(
- cfg_Prop* p,
- Arena* arena,
- const char* start
-) {
- const char* c;
- int len;
- for (; *start && (*start == ' ' || *start == '\t'); start++);
- for (len = 0, c = start; *c && *c != '\n'; c++, len++);
- switch (start[0]) {
- case '"':
- fill_prop_string(p, arena, start + 1, len - 1);
- break;
- case '0': case '1': case '2':
- case '3': case '4': case '5':
- case '6': case '7': case '8':
- case '9': case '-':
- fill_prop_number(p, start, len);
- break;
- case 'f': case 't':
- fill_prop_bool(p, start, len);
- break;
- case '$':
- fill_prop_data(p, arena, start + 1, len - 1);
- break;
- default:
- p->type = cfg_type_none;
- break;
- }
-}
-
-cfg_Object* cfg_parse(const char* src, Arena* arena) {
- const char* line, * start;
- int len;
- cfg_Object* root = 0, * obj = 0, * pobj;
- cfg_Prop* prop = 0, * pprop;
- for (line = src; line; line = next_line(line)) {
- len = 0;
- if (is_object(line, &start, &len) || line == src) {
- pobj = obj;
- obj = arena_alloc(arena, sizeof *obj);
- obj->prop_count = 0;
- obj->props = 0;
- obj->next = 0;
- memcpy(obj->name, start, len);
- obj->name[len] = 0;
- if (!root)
- root = obj;
- else
- pobj->next = obj;
- } else if (!obj) continue;
- if (is_prop(line, &start, &len)) {
- pprop = prop;
- prop = arena_alloc(arena, sizeof *prop);
- prop->next = 0;
- memcpy(prop->name, start, len);
- prop->name[len] = 0;
- fill_prop_val(prop, arena, line + len + 1);
- obj->prop_count++;
- if (!obj->props)
- obj->props = prop;
- else
- pprop->next = prop;
- }
- }
- return root;
-}
-
-const cfg_Prop* find_prop(
- const cfg_Object* obj,
- const char* name
-) {
- const cfg_Prop* p;
- for (p = obj->props; p; p = p->next) {
- if (!strcmp(p->name, name)) {
- return p;
- }
- }
- return 0;
-}
-
-const cfg_Prop* find_prop_of(
- const cfg_Object* obj,
- const char* name,
- cfg_Type type
-) {
- const cfg_Prop* p;
- for (p = obj->props; p; p = p->next) {
- if (p->type == type && !strcmp(p->name, name)) {
- return p;
- }
- }
- return 0;
-}
-
-int find_int_default(
- const cfg_Object* obj,
- const char* name,
- int def
-) {
- const cfg_Prop* prop;
- prop = find_prop_of(obj, name, cfg_type_int);
- if (prop) {
- return prop->as.num;
- }
- return def;
-}
-
-const char* find_string_default(
- const cfg_Object* obj,
- const char* name,
- const char* def
-) {
- const cfg_Prop* prop;
- prop = find_prop_of(obj, name, cfg_type_string);
- if (prop) {
- return prop->as.str;
- }
- return def;
-}
diff --git a/cfgparse.h b/cfgparse.h
deleted file mode 100644
index f8eeedb..0000000
--- a/cfgparse.h
+++ /dev/null
@@ -1,58 +0,0 @@
-#ifndef cfgparse_h
-#define cfgparse_h
-
-#include "memory.h"
-
-typedef enum {
- cfg_type_int,
- cfg_type_string,
- cfg_type_data,
- cfg_type_none
-} cfg_Type;
-
-typedef struct {
- int size;
- char* data;
-} cfg_Data;
-
-typedef struct cfg_Prop {
- char name[28];
- cfg_Type type;
- union {
- int num;
- cfg_Data data;
- char* str;
- } as;
- struct cfg_Prop* next;
-} cfg_Prop;
-
-typedef struct cfg_Object {
- char name[28];
- int prop_count;
- cfg_Prop* props;
- struct cfg_Object* next;
-} cfg_Object;
-
-cfg_Object* cfg_parse(const char* src, Arena* arena);
-const cfg_Prop* find_prop(
- const cfg_Object* obj,
- const char* name
-);
-const cfg_Prop* find_prop_of(
- const cfg_Object* obj,
- const char* name,
- cfg_Type type
-);
-
-int find_int_default(
- const cfg_Object* obj,
- const char* name,
- int def
-);
-const char* find_string_default(
- const cfg_Object* obj,
- const char* name,
- const char* def
-);
-
-#endif
diff --git a/config.h b/config.h
index 612984f..e19aa30 100644
--- a/config.h
+++ b/config.h
@@ -4,30 +4,12 @@
#define app_name "Twink Player"
#define default_window_w 1280
#define default_window_h 960
-#define ms_per_frame 40 /* 25 FPS */
-#define max_songs 1024
-#define song_filename_max 256
-#define song_name_max 256
-#define library_folder "/home/quou/music/"
-
-/* font */
-#define default_font_location "/usr/share/fonts/TTF/DejaVuSans.ttf"
-#define default_font_size 20
-
-/* theme */
-#define theme_text_colour make_colour(0x000000, 0xff)
-#define theme_background_colour make_colour(0xffffff, 0xff)
-#define theme_outline_colour make_colour(0x000000, 0xff)
-#define theme_hovered_colour make_colour(0xcacaca, 0xff)
-#define theme_active_colour make_colour(0xf0f8ff, 0xff)
-#define theme_outline_width 2
-#define theme_padding 2
-
-/* from here on are parametres that are not designed to
- * be changed. */
-#define memory_heap_size (1024 * 1024 * 8)
+#define memory_heap_size (1024 * 1024 * 512)
#define memory_size (memory_heap_size + (1024 * 1024 * 8))
+#define library_memory_size (1024 * 1024 * 256)
+
+#define library_path "/home/quou/music/"
#if defined(is64bit) && is64bit
#define allocation_default_alignment 8
@@ -35,14 +17,4 @@
#define allocation_default_alignment 4
#endif
-#define fbits 9
-
-#define rcache_enable 1
-#define rcache_default_cell_w 128
-#define rcache_default_cell_h 128
-#define rcache_gw (default_window_w / rcache_default_cell_w)
-#define rcache_gh (default_window_w / rcache_default_cell_h)
-#define rcache_cmd_buf_size (1024 * 1024)
-#define rcache_hash_seed 2166136261
-
#endif
diff --git a/dr_flac.h b/dr_flac.h
new file mode 100644
index 0000000..14324cf
--- /dev/null
+++ b/dr_flac.h
@@ -0,0 +1,12536 @@
+/*
+FLAC audio decoder. Choice of public domain or MIT-0. See license statements at the end of this file.
+dr_flac - v0.12.42 - 2023-11-02
+
+David Reid - mackron@gmail.com
+
+GitHub: https://github.com/mackron/dr_libs
+*/
+
+/*
+RELEASE NOTES - v0.12.0
+=======================
+Version 0.12.0 has breaking API changes including changes to the existing API and the removal of deprecated APIs.
+
+
+Improved Client-Defined Memory Allocation
+-----------------------------------------
+The main change with this release is the addition of a more flexible way of implementing custom memory allocation routines. The
+existing system of DRFLAC_MALLOC, DRFLAC_REALLOC and DRFLAC_FREE are still in place and will be used by default when no custom
+allocation callbacks are specified.
+
+To use the new system, you pass in a pointer to a drflac_allocation_callbacks object to drflac_open() and family, like this:
+
+ void* my_malloc(size_t sz, void* pUserData)
+ {
+ return malloc(sz);
+ }
+ void* my_realloc(void* p, size_t sz, void* pUserData)
+ {
+ return realloc(p, sz);
+ }
+ void my_free(void* p, void* pUserData)
+ {
+ free(p);
+ }
+
+ ...
+
+ drflac_allocation_callbacks allocationCallbacks;
+ allocationCallbacks.pUserData = &myData;
+ allocationCallbacks.onMalloc = my_malloc;
+ allocationCallbacks.onRealloc = my_realloc;
+ allocationCallbacks.onFree = my_free;
+ drflac* pFlac = drflac_open_file("my_file.flac", &allocationCallbacks);
+
+The advantage of this new system is that it allows you to specify user data which will be passed in to the allocation routines.
+
+Passing in null for the allocation callbacks object will cause dr_flac to use defaults which is the same as DRFLAC_MALLOC,
+DRFLAC_REALLOC and DRFLAC_FREE and the equivalent of how it worked in previous versions.
+
+Every API that opens a drflac object now takes this extra parameter. These include the following:
+
+ drflac_open()
+ drflac_open_relaxed()
+ drflac_open_with_metadata()
+ drflac_open_with_metadata_relaxed()
+ drflac_open_file()
+ drflac_open_file_with_metadata()
+ drflac_open_memory()
+ drflac_open_memory_with_metadata()
+ drflac_open_and_read_pcm_frames_s32()
+ drflac_open_and_read_pcm_frames_s16()
+ drflac_open_and_read_pcm_frames_f32()
+ drflac_open_file_and_read_pcm_frames_s32()
+ drflac_open_file_and_read_pcm_frames_s16()
+ drflac_open_file_and_read_pcm_frames_f32()
+ drflac_open_memory_and_read_pcm_frames_s32()
+ drflac_open_memory_and_read_pcm_frames_s16()
+ drflac_open_memory_and_read_pcm_frames_f32()
+
+
+
+Optimizations
+-------------
+Seeking performance has been greatly improved. A new binary search based seeking algorithm has been introduced which significantly
+improves performance over the brute force method which was used when no seek table was present. Seek table based seeking also takes
+advantage of the new binary search seeking system to further improve performance there as well. Note that this depends on CRC which
+means it will be disabled when DR_FLAC_NO_CRC is used.
+
+The SSE4.1 pipeline has been cleaned up and optimized. You should see some improvements with decoding speed of 24-bit files in
+particular. 16-bit streams should also see some improvement.
+
+drflac_read_pcm_frames_s16() has been optimized. Previously this sat on top of drflac_read_pcm_frames_s32() and performed it's s32
+to s16 conversion in a second pass. This is now all done in a single pass. This includes SSE2 and ARM NEON optimized paths.
+
+A minor optimization has been implemented for drflac_read_pcm_frames_s32(). This will now use an SSE2 optimized pipeline for stereo
+channel reconstruction which is the last part of the decoding process.
+
+The ARM build has seen a few improvements. The CLZ (count leading zeroes) and REV (byte swap) instructions are now used when
+compiling with GCC and Clang which is achieved using inline assembly. The CLZ instruction requires ARM architecture version 5 at
+compile time and the REV instruction requires ARM architecture version 6.
+
+An ARM NEON optimized pipeline has been implemented. To enable this you'll need to add -mfpu=neon to the command line when compiling.
+
+
+Removed APIs
+------------
+The following APIs were deprecated in version 0.11.0 and have been completely removed in version 0.12.0:
+
+ drflac_read_s32() -> drflac_read_pcm_frames_s32()
+ drflac_read_s16() -> drflac_read_pcm_frames_s16()
+ drflac_read_f32() -> drflac_read_pcm_frames_f32()
+ drflac_seek_to_sample() -> drflac_seek_to_pcm_frame()
+ drflac_open_and_decode_s32() -> drflac_open_and_read_pcm_frames_s32()
+ drflac_open_and_decode_s16() -> drflac_open_and_read_pcm_frames_s16()
+ drflac_open_and_decode_f32() -> drflac_open_and_read_pcm_frames_f32()
+ drflac_open_and_decode_file_s32() -> drflac_open_file_and_read_pcm_frames_s32()
+ drflac_open_and_decode_file_s16() -> drflac_open_file_and_read_pcm_frames_s16()
+ drflac_open_and_decode_file_f32() -> drflac_open_file_and_read_pcm_frames_f32()
+ drflac_open_and_decode_memory_s32() -> drflac_open_memory_and_read_pcm_frames_s32()
+ drflac_open_and_decode_memory_s16() -> drflac_open_memory_and_read_pcm_frames_s16()
+ drflac_open_and_decode_memory_f32() -> drflac_open_memroy_and_read_pcm_frames_f32()
+
+Prior versions of dr_flac operated on a per-sample basis whereas now it operates on PCM frames. The removed APIs all relate
+to the old per-sample APIs. You now need to use the "pcm_frame" versions.
+*/
+
+
+/*
+Introduction
+============
+dr_flac is a single file library. To use it, do something like the following in one .c file.
+
+ ```c
+ #define DR_FLAC_IMPLEMENTATION
+ #include "dr_flac.h"
+ ```
+
+You can then #include this file in other parts of the program as you would with any other header file. To decode audio data, do something like the following:
+
+ ```c
+ drflac* pFlac = drflac_open_file("MySong.flac", NULL);
+ if (pFlac == NULL) {
+ // Failed to open FLAC file
+ }
+
+ drflac_int32* pSamples = malloc(pFlac->totalPCMFrameCount * pFlac->channels * sizeof(drflac_int32));
+ drflac_uint64 numberOfInterleavedSamplesActuallyRead = drflac_read_pcm_frames_s32(pFlac, pFlac->totalPCMFrameCount, pSamples);
+ ```
+
+The drflac object represents the decoder. It is a transparent type so all the information you need, such as the number of channels and the bits per sample,
+should be directly accessible - just make sure you don't change their values. Samples are always output as interleaved signed 32-bit PCM. In the example above
+a native FLAC stream was opened, however dr_flac has seamless support for Ogg encapsulated FLAC streams as well.
+
+You do not need to decode the entire stream in one go - you just specify how many samples you'd like at any given time and the decoder will give you as many
+samples as it can, up to the amount requested. Later on when you need the next batch of samples, just call it again. Example:
+
+ ```c
+ while (drflac_read_pcm_frames_s32(pFlac, chunkSizeInPCMFrames, pChunkSamples) > 0) {
+ do_something();
+ }
+ ```
+
+You can seek to a specific PCM frame with `drflac_seek_to_pcm_frame()`.
+
+If you just want to quickly decode an entire FLAC file in one go you can do something like this:
+
+ ```c
+ unsigned int channels;
+ unsigned int sampleRate;
+ drflac_uint64 totalPCMFrameCount;
+ drflac_int32* pSampleData = drflac_open_file_and_read_pcm_frames_s32("MySong.flac", &channels, &sampleRate, &totalPCMFrameCount, NULL);
+ if (pSampleData == NULL) {
+ // Failed to open and decode FLAC file.
+ }
+
+ ...
+
+ drflac_free(pSampleData, NULL);
+ ```
+
+You can read samples as signed 16-bit integer and 32-bit floating-point PCM with the *_s16() and *_f32() family of APIs respectively, but note that these
+should be considered lossy.
+
+
+If you need access to metadata (album art, etc.), use `drflac_open_with_metadata()`, `drflac_open_file_with_metdata()` or `drflac_open_memory_with_metadata()`.
+The rationale for keeping these APIs separate is that they're slightly slower than the normal versions and also just a little bit harder to use. dr_flac
+reports metadata to the application through the use of a callback, and every metadata block is reported before `drflac_open_with_metdata()` returns.
+
+The main opening APIs (`drflac_open()`, etc.) will fail if the header is not present. The presents a problem in certain scenarios such as broadcast style
+streams or internet radio where the header may not be present because the user has started playback mid-stream. To handle this, use the relaxed APIs:
+
+ `drflac_open_relaxed()`
+ `drflac_open_with_metadata_relaxed()`
+
+It is not recommended to use these APIs for file based streams because a missing header would usually indicate a corrupt or perverse file. In addition, these
+APIs can take a long time to initialize because they may need to spend a lot of time finding the first frame.
+
+
+
+Build Options
+=============
+#define these options before including this file.
+
+#define DR_FLAC_NO_STDIO
+ Disable `drflac_open_file()` and family.
+
+#define DR_FLAC_NO_OGG
+ Disables support for Ogg/FLAC streams.
+
+#define DR_FLAC_BUFFER_SIZE <number>
+ Defines the size of the internal buffer to store data from onRead(). This buffer is used to reduce the number of calls back to the client for more data.
+ Larger values means more memory, but better performance. My tests show diminishing returns after about 4KB (which is the default). Consider reducing this if
+ you have a very efficient implementation of onRead(), or increase it if it's very inefficient. Must be a multiple of 8.
+
+#define DR_FLAC_NO_CRC
+ Disables CRC checks. This will offer a performance boost when CRC is unnecessary. This will disable binary search seeking. When seeking, the seek table will
+ be used if available. Otherwise the seek will be performed using brute force.
+
+#define DR_FLAC_NO_SIMD
+ Disables SIMD optimizations (SSE on x86/x64 architectures, NEON on ARM architectures). Use this if you are having compatibility issues with your compiler.
+
+#define DR_FLAC_NO_WCHAR
+ Disables all functions ending with `_w`. Use this if your compiler does not provide wchar.h. Not required if DR_FLAC_NO_STDIO is also defined.
+
+
+
+Notes
+=====
+- dr_flac does not support changing the sample rate nor channel count mid stream.
+- dr_flac is not thread-safe, but its APIs can be called from any thread so long as you do your own synchronization.
+- When using Ogg encapsulation, a corrupted metadata block will result in `drflac_open_with_metadata()` and `drflac_open()` returning inconsistent samples due
+ to differences in corrupted stream recorvery logic between the two APIs.
+*/
+
+#ifndef dr_flac_h
+#define dr_flac_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define DRFLAC_STRINGIFY(x) #x
+#define DRFLAC_XSTRINGIFY(x) DRFLAC_STRINGIFY(x)
+
+#define DRFLAC_VERSION_MAJOR 0
+#define DRFLAC_VERSION_MINOR 12
+#define DRFLAC_VERSION_REVISION 42
+#define DRFLAC_VERSION_STRING DRFLAC_XSTRINGIFY(DRFLAC_VERSION_MAJOR) "." DRFLAC_XSTRINGIFY(DRFLAC_VERSION_MINOR) "." DRFLAC_XSTRINGIFY(DRFLAC_VERSION_REVISION)
+
+#include <stddef.h> /* For size_t. */
+
+/* Sized Types */
+typedef signed char drflac_int8;
+typedef unsigned char drflac_uint8;
+typedef signed short drflac_int16;
+typedef unsigned short drflac_uint16;
+typedef signed int drflac_int32;
+typedef unsigned int drflac_uint32;
+#if defined(_MSC_VER) && !defined(__clang__)
+ typedef signed __int64 drflac_int64;
+ typedef unsigned __int64 drflac_uint64;
+#else
+ #if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))
+ #pragma GCC diagnostic push
+ #pragma GCC diagnostic ignored "-Wlong-long"
+ #if defined(__clang__)
+ #pragma GCC diagnostic ignored "-Wc++11-long-long"
+ #endif
+ #endif
+ typedef signed long long drflac_int64;
+ typedef unsigned long long drflac_uint64;
+ #if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))
+ #pragma GCC diagnostic pop
+ #endif
+#endif
+#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__)) || defined(_M_X64) || defined(__ia64) || defined(_M_IA64) || defined(__aarch64__) || defined(_M_ARM64) || defined(__powerpc64__)
+ typedef drflac_uint64 drflac_uintptr;
+#else
+ typedef drflac_uint32 drflac_uintptr;
+#endif
+typedef drflac_uint8 drflac_bool8;
+typedef drflac_uint32 drflac_bool32;
+#define DRFLAC_TRUE 1
+#define DRFLAC_FALSE 0
+/* End Sized Types */
+
+/* Decorations */
+#if !defined(DRFLAC_API)
+ #if defined(DRFLAC_DLL)
+ #if defined(_WIN32)
+ #define DRFLAC_DLL_IMPORT __declspec(dllimport)
+ #define DRFLAC_DLL_EXPORT __declspec(dllexport)
+ #define DRFLAC_DLL_PRIVATE static
+ #else
+ #if defined(__GNUC__) && __GNUC__ >= 4
+ #define DRFLAC_DLL_IMPORT __attribute__((visibility("default")))
+ #define DRFLAC_DLL_EXPORT __attribute__((visibility("default")))
+ #define DRFLAC_DLL_PRIVATE __attribute__((visibility("hidden")))
+ #else
+ #define DRFLAC_DLL_IMPORT
+ #define DRFLAC_DLL_EXPORT
+ #define DRFLAC_DLL_PRIVATE static
+ #endif
+ #endif
+
+ #if defined(DR_FLAC_IMPLEMENTATION) || defined(DRFLAC_IMPLEMENTATION)
+ #define DRFLAC_API DRFLAC_DLL_EXPORT
+ #else
+ #define DRFLAC_API DRFLAC_DLL_IMPORT
+ #endif
+ #define DRFLAC_PRIVATE DRFLAC_DLL_PRIVATE
+ #else
+ #define DRFLAC_API extern
+ #define DRFLAC_PRIVATE static
+ #endif
+#endif
+/* End Decorations */
+
+#if defined(_MSC_VER) && _MSC_VER >= 1700 /* Visual Studio 2012 */
+ #define DRFLAC_DEPRECATED __declspec(deprecated)
+#elif (defined(__GNUC__) && __GNUC__ >= 4) /* GCC 4 */
+ #define DRFLAC_DEPRECATED __attribute__((deprecated))
+#elif defined(__has_feature) /* Clang */
+ #if __has_feature(attribute_deprecated)
+ #define DRFLAC_DEPRECATED __attribute__((deprecated))
+ #else
+ #define DRFLAC_DEPRECATED
+ #endif
+#else
+ #define DRFLAC_DEPRECATED
+#endif
+
+DRFLAC_API void drflac_version(drflac_uint32* pMajor, drflac_uint32* pMinor, drflac_uint32* pRevision);
+DRFLAC_API const char* drflac_version_string(void);
+
+/* Allocation Callbacks */
+typedef struct
+{
+ void* pUserData;
+ void* (* onMalloc)(size_t sz, void* pUserData);
+ void* (* onRealloc)(void* p, size_t sz, void* pUserData);
+ void (* onFree)(void* p, void* pUserData);
+} drflac_allocation_callbacks;
+/* End Allocation Callbacks */
+
+/*
+As data is read from the client it is placed into an internal buffer for fast access. This controls the size of that buffer. Larger values means more speed,
+but also more memory. In my testing there is diminishing returns after about 4KB, but you can fiddle with this to suit your own needs. Must be a multiple of 8.
+*/
+#ifndef DR_FLAC_BUFFER_SIZE
+#define DR_FLAC_BUFFER_SIZE 4096
+#endif
+
+
+/* Architecture Detection */
+#if defined(_WIN64) || defined(_LP64) || defined(__LP64__)
+#define DRFLAC_64BIT
+#endif
+
+#if defined(__x86_64__) || defined(_M_X64)
+ #define DRFLAC_X64
+#elif defined(__i386) || defined(_M_IX86)
+ #define DRFLAC_X86
+#elif defined(__arm__) || defined(_M_ARM) || defined(__arm64) || defined(__arm64__) || defined(__aarch64__) || defined(_M_ARM64)
+ #define DRFLAC_ARM
+#endif
+/* End Architecture Detection */
+
+
+#ifdef DRFLAC_64BIT
+typedef drflac_uint64 drflac_cache_t;
+#else
+typedef drflac_uint32 drflac_cache_t;
+#endif
+
+/* The various metadata block types. */
+#define DRFLAC_METADATA_BLOCK_TYPE_STREAMINFO 0
+#define DRFLAC_METADATA_BLOCK_TYPE_PADDING 1
+#define DRFLAC_METADATA_BLOCK_TYPE_APPLICATION 2
+#define DRFLAC_METADATA_BLOCK_TYPE_SEEKTABLE 3
+#define DRFLAC_METADATA_BLOCK_TYPE_VORBIS_COMMENT 4
+#define DRFLAC_METADATA_BLOCK_TYPE_CUESHEET 5
+#define DRFLAC_METADATA_BLOCK_TYPE_PICTURE 6
+#define DRFLAC_METADATA_BLOCK_TYPE_INVALID 127
+
+/* The various picture types specified in the PICTURE block. */
+#define DRFLAC_PICTURE_TYPE_OTHER 0
+#define DRFLAC_PICTURE_TYPE_FILE_ICON 1
+#define DRFLAC_PICTURE_TYPE_OTHER_FILE_ICON 2
+#define DRFLAC_PICTURE_TYPE_COVER_FRONT 3
+#define DRFLAC_PICTURE_TYPE_COVER_BACK 4
+#define DRFLAC_PICTURE_TYPE_LEAFLET_PAGE 5
+#define DRFLAC_PICTURE_TYPE_MEDIA 6
+#define DRFLAC_PICTURE_TYPE_LEAD_ARTIST 7
+#define DRFLAC_PICTURE_TYPE_ARTIST 8
+#define DRFLAC_PICTURE_TYPE_CONDUCTOR 9
+#define DRFLAC_PICTURE_TYPE_BAND 10
+#define DRFLAC_PICTURE_TYPE_COMPOSER 11
+#define DRFLAC_PICTURE_TYPE_LYRICIST 12
+#define DRFLAC_PICTURE_TYPE_RECORDING_LOCATION 13
+#define DRFLAC_PICTURE_TYPE_DURING_RECORDING 14
+#define DRFLAC_PICTURE_TYPE_DURING_PERFORMANCE 15
+#define DRFLAC_PICTURE_TYPE_SCREEN_CAPTURE 16
+#define DRFLAC_PICTURE_TYPE_BRIGHT_COLORED_FISH 17
+#define DRFLAC_PICTURE_TYPE_ILLUSTRATION 18
+#define DRFLAC_PICTURE_TYPE_BAND_LOGOTYPE 19
+#define DRFLAC_PICTURE_TYPE_PUBLISHER_LOGOTYPE 20
+
+typedef enum
+{
+ drflac_container_native,
+ drflac_container_ogg,
+ drflac_container_unknown
+} drflac_container;
+
+typedef enum
+{
+ drflac_seek_origin_start,
+ drflac_seek_origin_current
+} drflac_seek_origin;
+
+/* The order of members in this structure is important because we map this directly to the raw data within the SEEKTABLE metadata block. */
+typedef struct
+{
+ drflac_uint64 firstPCMFrame;
+ drflac_uint64 flacFrameOffset; /* The offset from the first byte of the header of the first frame. */
+ drflac_uint16 pcmFrameCount;
+} drflac_seekpoint;
+
+typedef struct
+{
+ drflac_uint16 minBlockSizeInPCMFrames;
+ drflac_uint16 maxBlockSizeInPCMFrames;
+ drflac_uint32 minFrameSizeInPCMFrames;
+ drflac_uint32 maxFrameSizeInPCMFrames;
+ drflac_uint32 sampleRate;
+ drflac_uint8 channels;
+ drflac_uint8 bitsPerSample;
+ drflac_uint64 totalPCMFrameCount;
+ drflac_uint8 md5[16];
+} drflac_streaminfo;
+
+typedef struct
+{
+ /*
+ The metadata type. Use this to know how to interpret the data below. Will be set to one of the
+ DRFLAC_METADATA_BLOCK_TYPE_* tokens.
+ */
+ drflac_uint32 type;
+
+ /*
+ A pointer to the raw data. This points to a temporary buffer so don't hold on to it. It's best to
+ not modify the contents of this buffer. Use the structures below for more meaningful and structured
+ information about the metadata. It's possible for this to be null.
+ */
+ const void* pRawData;
+
+ /* The size in bytes of the block and the buffer pointed to by pRawData if it's non-NULL. */
+ drflac_uint32 rawDataSize;
+
+ union
+ {
+ drflac_streaminfo streaminfo;
+
+ struct
+ {
+ int unused;
+ } padding;
+
+ struct
+ {
+ drflac_uint32 id;
+ const void* pData;
+ drflac_uint32 dataSize;
+ } application;
+
+ struct
+ {
+ drflac_uint32 seekpointCount;
+ const drflac_seekpoint* pSeekpoints;
+ } seektable;
+
+ struct
+ {
+ drflac_uint32 vendorLength;
+ const char* vendor;
+ drflac_uint32 commentCount;
+ const void* pComments;
+ } vorbis_comment;
+
+ struct
+ {
+ char catalog[128];
+ drflac_uint64 leadInSampleCount;
+ drflac_bool32 isCD;
+ drflac_uint8 trackCount;
+ const void* pTrackData;
+ } cuesheet;
+
+ struct
+ {
+ drflac_uint32 type;
+ drflac_uint32 mimeLength;
+ const char* mime;
+ drflac_uint32 descriptionLength;
+ const char* description;
+ drflac_uint32 width;
+ drflac_uint32 height;
+ drflac_uint32 colorDepth;
+ drflac_uint32 indexColorCount;
+ drflac_uint32 pictureDataSize;
+ const drflac_uint8* pPictureData;
+ } picture;
+ } data;
+} drflac_metadata;
+
+
+/*
+Callback for when data needs to be read from the client.
+
+
+Parameters
+----------
+pUserData (in)
+ The user data that was passed to drflac_open() and family.
+
+pBufferOut (out)
+ The output buffer.
+
+bytesToRead (in)
+ The number of bytes to read.
+
+
+Return Value
+------------
+The number of bytes actually read.
+
+
+Remarks
+-------
+A return value of less than bytesToRead indicates the end of the stream. Do _not_ return from this callback until either the entire bytesToRead is filled or
+you have reached the end of the stream.
+*/
+typedef size_t (* drflac_read_proc)(void* pUserData, void* pBufferOut, size_t bytesToRead);
+
+/*
+Callback for when data needs to be seeked.
+
+
+Parameters
+----------
+pUserData (in)
+ The user data that was passed to drflac_open() and family.
+
+offset (in)
+ The number of bytes to move, relative to the origin. Will never be negative.
+
+origin (in)
+ The origin of the seek - the current position or the start of the stream.
+
+
+Return Value
+------------
+Whether or not the seek was successful.
+
+
+Remarks
+-------
+The offset will never be negative. Whether or not it is relative to the beginning or current position is determined by the "origin" parameter which will be
+either drflac_seek_origin_start or drflac_seek_origin_current.
+
+When seeking to a PCM frame using drflac_seek_to_pcm_frame(), dr_flac may call this with an offset beyond the end of the FLAC stream. This needs to be detected
+and handled by returning DRFLAC_FALSE.
+*/
+typedef drflac_bool32 (* drflac_seek_proc)(void* pUserData, int offset, drflac_seek_origin origin);
+
+/*
+Callback for when a metadata block is read.
+
+
+Parameters
+----------
+pUserData (in)
+ The user data that was passed to drflac_open() and family.
+
+pMetadata (in)
+ A pointer to a structure containing the data of the metadata block.
+
+
+Remarks
+-------
+Use pMetadata->type to determine which metadata block is being handled and how to read the data. This
+will be set to one of the DRFLAC_METADATA_BLOCK_TYPE_* tokens.
+*/
+typedef void (* drflac_meta_proc)(void* pUserData, drflac_metadata* pMetadata);
+
+
+/* Structure for internal use. Only used for decoders opened with drflac_open_memory. */
+typedef struct
+{
+ const drflac_uint8* data;
+ size_t dataSize;
+ size_t currentReadPos;
+} drflac__memory_stream;
+
+/* Structure for internal use. Used for bit streaming. */
+typedef struct
+{
+ /* The function to call when more data needs to be read. */
+ drflac_read_proc onRead;
+
+ /* The function to call when the current read position needs to be moved. */
+ drflac_seek_proc onSeek;
+
+ /* The user data to pass around to onRead and onSeek. */
+ void* pUserData;
+
+
+ /*
+ The number of unaligned bytes in the L2 cache. This will always be 0 until the end of the stream is hit. At the end of the
+ stream there will be a number of bytes that don't cleanly fit in an L1 cache line, so we use this variable to know whether
+ or not the bistreamer needs to run on a slower path to read those last bytes. This will never be more than sizeof(drflac_cache_t).
+ */
+ size_t unalignedByteCount;
+
+ /* The content of the unaligned bytes. */
+ drflac_cache_t unalignedCache;
+
+ /* The index of the next valid cache line in the "L2" cache. */
+ drflac_uint32 nextL2Line;
+
+ /* The number of bits that have been consumed by the cache. This is used to determine how many valid bits are remaining. */
+ drflac_uint32 consumedBits;
+
+ /*
+ The cached data which was most recently read from the client. There are two levels of cache. Data flows as such:
+ Client -> L2 -> L1. The L2 -> L1 movement is aligned and runs on a fast path in just a few instructions.
+ */
+ drflac_cache_t cacheL2[DR_FLAC_BUFFER_SIZE/sizeof(drflac_cache_t)];
+ drflac_cache_t cache;
+
+ /*
+ CRC-16. This is updated whenever bits are read from the bit stream. Manually set this to 0 to reset the CRC. For FLAC, this
+ is reset to 0 at the beginning of each frame.
+ */
+ drflac_uint16 crc16;
+ drflac_cache_t crc16Cache; /* A cache for optimizing CRC calculations. This is filled when when the L1 cache is reloaded. */
+ drflac_uint32 crc16CacheIgnoredBytes; /* The number of bytes to ignore when updating the CRC-16 from the CRC-16 cache. */
+} drflac_bs;
+
+typedef struct
+{
+ /* The type of the subframe: SUBFRAME_CONSTANT, SUBFRAME_VERBATIM, SUBFRAME_FIXED or SUBFRAME_LPC. */
+ drflac_uint8 subframeType;
+
+ /* The number of wasted bits per sample as specified by the sub-frame header. */
+ drflac_uint8 wastedBitsPerSample;
+
+ /* The order to use for the prediction stage for SUBFRAME_FIXED and SUBFRAME_LPC. */
+ drflac_uint8 lpcOrder;
+
+ /* A pointer to the buffer containing the decoded samples in the subframe. This pointer is an offset from drflac::pExtraData. */
+ drflac_int32* pSamplesS32;
+} drflac_subframe;
+
+typedef struct
+{
+ /*
+ If the stream uses variable block sizes, this will be set to the index of the first PCM frame. If fixed block sizes are used, this will
+ always be set to 0. This is 64-bit because the decoded PCM frame number will be 36 bits.
+ */
+ drflac_uint64 pcmFrameNumber;
+
+ /*
+ If the stream uses fixed block sizes, this will be set to the frame number. If variable block sizes are used, this will always be 0. This
+ is 32-bit because in fixed block sizes, the maximum frame number will be 31 bits.
+ */
+ drflac_uint32 flacFrameNumber;
+
+ /* The sample rate of this frame. */
+ drflac_uint32 sampleRate;
+
+ /* The number of PCM frames in each sub-frame within this frame. */
+ drflac_uint16 blockSizeInPCMFrames;
+
+ /*
+ The channel assignment of this frame. This is not always set to the channel count. If interchannel decorrelation is being used this
+ will be set to DRFLAC_CHANNEL_ASSIGNMENT_LEFT_SIDE, DRFLAC_CHANNEL_ASSIGNMENT_RIGHT_SIDE or DRFLAC_CHANNEL_ASSIGNMENT_MID_SIDE.
+ */
+ drflac_uint8 channelAssignment;
+
+ /* The number of bits per sample within this frame. */
+ drflac_uint8 bitsPerSample;
+
+ /* The frame's CRC. */
+ drflac_uint8 crc8;
+} drflac_frame_header;
+
+typedef struct
+{
+ /* The header. */
+ drflac_frame_header header;
+
+ /*
+ The number of PCM frames left to be read in this FLAC frame. This is initially set to the block size. As PCM frames are read,
+ this will be decremented. When it reaches 0, the decoder will see this frame as fully consumed and load the next frame.
+ */
+ drflac_uint32 pcmFramesRemaining;
+
+ /* The list of sub-frames within the frame. There is one sub-frame for each channel, and there's a maximum of 8 channels. */
+ drflac_subframe subframes[8];
+} drflac_frame;
+
+typedef struct
+{
+ /* The function to call when a metadata block is read. */
+ drflac_meta_proc onMeta;
+
+ /* The user data posted to the metadata callback function. */
+ void* pUserDataMD;
+
+ /* Memory allocation callbacks. */
+ drflac_allocation_callbacks allocationCallbacks;
+
+
+ /* The sample rate. Will be set to something like 44100. */
+ drflac_uint32 sampleRate;
+
+ /*
+ The number of channels. This will be set to 1 for monaural streams, 2 for stereo, etc. Maximum 8. This is set based on the
+ value specified in the STREAMINFO block.
+ */
+ drflac_uint8 channels;
+
+ /* The bits per sample. Will be set to something like 16, 24, etc. */
+ drflac_uint8 bitsPerSample;
+
+ /* The maximum block size, in samples. This number represents the number of samples in each channel (not combined). */
+ drflac_uint16 maxBlockSizeInPCMFrames;
+
+ /*
+ The total number of PCM Frames making up the stream. Can be 0 in which case it's still a valid stream, but just means
+ the total PCM frame count is unknown. Likely the case with streams like internet radio.
+ */
+ drflac_uint64 totalPCMFrameCount;
+
+
+ /* The container type. This is set based on whether or not the decoder was opened from a native or Ogg stream. */
+ drflac_container container;
+
+ /* The number of seekpoints in the seektable. */
+ drflac_uint32 seekpointCount;
+
+
+ /* Information about the frame the decoder is currently sitting on. */
+ drflac_frame currentFLACFrame;
+
+
+ /* The index of the PCM frame the decoder is currently sitting on. This is only used for seeking. */
+ drflac_uint64 currentPCMFrame;
+
+ /* The position of the first FLAC frame in the stream. This is only ever used for seeking. */
+ drflac_uint64 firstFLACFramePosInBytes;
+
+
+ /* A hack to avoid a malloc() when opening a decoder with drflac_open_memory(). */
+ drflac__memory_stream memoryStream;
+
+
+ /* A pointer to the decoded sample data. This is an offset of pExtraData. */
+ drflac_int32* pDecodedSamples;
+
+ /* A pointer to the seek table. This is an offset of pExtraData, or NULL if there is no seek table. */
+ drflac_seekpoint* pSeekpoints;
+
+ /* Internal use only. Only used with Ogg containers. Points to a drflac_oggbs object. This is an offset of pExtraData. */
+ void* _oggbs;
+
+ /* Internal use only. Used for profiling and testing different seeking modes. */
+ drflac_bool32 _noSeekTableSeek : 1;
+ drflac_bool32 _noBinarySearchSeek : 1;
+ drflac_bool32 _noBruteForceSeek : 1;
+
+ /* The bit streamer. The raw FLAC data is fed through this object. */
+ drflac_bs bs;
+
+ /* Variable length extra data. We attach this to the end of the object so we can avoid unnecessary mallocs. */
+ drflac_uint8 pExtraData[1];
+} drflac;
+
+
+/*
+Opens a FLAC decoder.
+
+
+Parameters
+----------
+onRead (in)
+ The function to call when data needs to be read from the client.
+
+onSeek (in)
+ The function to call when the read position of the client data needs to move.
+
+pUserData (in, optional)
+ A pointer to application defined data that will be passed to onRead and onSeek.
+
+pAllocationCallbacks (in, optional)
+ A pointer to application defined callbacks for managing memory allocations.
+
+
+Return Value
+------------
+Returns a pointer to an object representing the decoder.
+
+
+Remarks
+-------
+Close the decoder with `drflac_close()`.
+
+`pAllocationCallbacks` can be NULL in which case it will use `DRFLAC_MALLOC`, `DRFLAC_REALLOC` and `DRFLAC_FREE`.
+
+This function will automatically detect whether or not you are attempting to open a native or Ogg encapsulated FLAC, both of which should work seamlessly
+without any manual intervention. Ogg encapsulation also works with multiplexed streams which basically means it can play FLAC encoded audio tracks in videos.
+
+This is the lowest level function for opening a FLAC stream. You can also use `drflac_open_file()` and `drflac_open_memory()` to open the stream from a file or
+from a block of memory respectively.
+
+The STREAMINFO block must be present for this to succeed. Use `drflac_open_relaxed()` to open a FLAC stream where the header may not be present.
+
+Use `drflac_open_with_metadata()` if you need access to metadata.
+
+
+Seek Also
+---------
+drflac_open_file()
+drflac_open_memory()
+drflac_open_with_metadata()
+drflac_close()
+*/
+DRFLAC_API drflac* drflac_open(drflac_read_proc onRead, drflac_seek_proc onSeek, void* pUserData, const drflac_allocation_callbacks* pAllocationCallbacks);
+
+/*
+Opens a FLAC stream with relaxed validation of the header block.
+
+
+Parameters
+----------
+onRead (in)
+ The function to call when data needs to be read from the client.
+
+onSeek (in)
+ The function to call when the read position of the client data needs to move.
+
+container (in)
+ Whether or not the FLAC stream is encapsulated using standard FLAC encapsulation or Ogg encapsulation.
+
+pUserData (in, optional)
+ A pointer to application defined data that will be passed to onRead and onSeek.
+
+pAllocationCallbacks (in, optional)
+ A pointer to application defined callbacks for managing memory allocations.
+
+
+Return Value
+------------
+A pointer to an object representing the decoder.
+
+
+Remarks
+-------
+The same as drflac_open(), except attempts to open the stream even when a header block is not present.
+
+Because the header is not necessarily available, the caller must explicitly define the container (Native or Ogg). Do not set this to `drflac_container_unknown`
+as that is for internal use only.
+
+Opening in relaxed mode will continue reading data from onRead until it finds a valid frame. If a frame is never found it will continue forever. To abort,
+force your `onRead` callback to return 0, which dr_flac will use as an indicator that the end of the stream was found.
+
+Use `drflac_open_with_metadata_relaxed()` if you need access to metadata.
+*/
+DRFLAC_API drflac* drflac_open_relaxed(drflac_read_proc onRead, drflac_seek_proc onSeek, drflac_container container, void* pUserData, const drflac_allocation_callbacks* pAllocationCallbacks);
+
+/*
+Opens a FLAC decoder and notifies the caller of the metadata chunks (album art, etc.).
+
+
+Parameters
+----------
+onRead (in)
+ The function to call when data needs to be read from the client.
+
+onSeek (in)
+ The function to call when the read position of the client data needs to move.
+
+onMeta (in)
+ The function to call for every metadata block.
+
+pUserData (in, optional)
+ A pointer to application defined data that will be passed to onRead, onSeek and onMeta.
+
+pAllocationCallbacks (in, optional)
+ A pointer to application defined callbacks for managing memory allocations.
+
+
+Return Value
+------------
+A pointer to an object representing the decoder.
+
+
+Remarks
+-------
+Close the decoder with `drflac_close()`.
+
+`pAllocationCallbacks` can be NULL in which case it will use `DRFLAC_MALLOC`, `DRFLAC_REALLOC` and `DRFLAC_FREE`.
+
+This is slower than `drflac_open()`, so avoid this one if you don't need metadata. Internally, this will allocate and free memory on the heap for every
+metadata block except for STREAMINFO and PADDING blocks.
+
+The caller is notified of the metadata via the `onMeta` callback. All metadata blocks will be handled before the function returns. This callback takes a
+pointer to a `drflac_metadata` object which is a union containing the data of all relevant metadata blocks. Use the `type` member to discriminate against
+the different metadata types.
+
+The STREAMINFO block must be present for this to succeed. Use `drflac_open_with_metadata_relaxed()` to open a FLAC stream where the header may not be present.
+
+Note that this will behave inconsistently with `drflac_open()` if the stream is an Ogg encapsulated stream and a metadata block is corrupted. This is due to
+the way the Ogg stream recovers from corrupted pages. When `drflac_open_with_metadata()` is being used, the open routine will try to read the contents of the
+metadata block, whereas `drflac_open()` will simply seek past it (for the sake of efficiency). This inconsistency can result in different samples being
+returned depending on whether or not the stream is being opened with metadata.
+
+
+Seek Also
+---------
+drflac_open_file_with_metadata()
+drflac_open_memory_with_metadata()
+drflac_open()
+drflac_close()
+*/
+DRFLAC_API drflac* drflac_open_with_metadata(drflac_read_proc onRead, drflac_seek_proc onSeek, drflac_meta_proc onMeta, void* pUserData, const drflac_allocation_callbacks* pAllocationCallbacks);
+
+/*
+The same as drflac_open_with_metadata(), except attempts to open the stream even when a header block is not present.
+
+See Also
+--------
+drflac_open_with_metadata()
+drflac_open_relaxed()
+*/
+DRFLAC_API drflac* drflac_open_with_metadata_relaxed(drflac_read_proc onRead, drflac_seek_proc onSeek, drflac_meta_proc onMeta, drflac_container container, void* pUserData, const drflac_allocation_callbacks* pAllocationCallbacks);
+
+/*
+Closes the given FLAC decoder.
+
+
+Parameters
+----------
+pFlac (in)
+ The decoder to close.
+
+
+Remarks
+-------
+This will destroy the decoder object.
+
+
+See Also
+--------
+drflac_open()
+drflac_open_with_metadata()
+drflac_open_file()
+drflac_open_file_w()
+drflac_open_file_with_metadata()
+drflac_open_file_with_metadata_w()
+drflac_open_memory()
+drflac_open_memory_with_metadata()
+*/
+DRFLAC_API void drflac_close(drflac* pFlac);
+
+
+/*
+Reads sample data from the given FLAC decoder, output as interleaved signed 32-bit PCM.
+
+
+Parameters
+----------
+pFlac (in)
+ The decoder.
+
+framesToRead (in)
+ The number of PCM frames to read.
+
+pBufferOut (out, optional)
+ A pointer to the buffer that will receive the decoded samples.
+
+
+Return Value
+------------
+Returns the number of PCM frames actually read. If the return value is less than `framesToRead` it has reached the end.
+
+
+Remarks
+-------
+pBufferOut can be null, in which case the call will act as a seek, and the return value will be the number of frames seeked.
+*/
+DRFLAC_API drflac_uint64 drflac_read_pcm_frames_s32(drflac* pFlac, drflac_uint64 framesToRead, drflac_int32* pBufferOut);
+
+
+/*
+Reads sample data from the given FLAC decoder, output as interleaved signed 16-bit PCM.
+
+
+Parameters
+----------
+pFlac (in)
+ The decoder.
+
+framesToRead (in)
+ The number of PCM frames to read.
+
+pBufferOut (out, optional)
+ A pointer to the buffer that will receive the decoded samples.
+
+
+Return Value
+------------
+Returns the number of PCM frames actually read. If the return value is less than `framesToRead` it has reached the end.
+
+
+Remarks
+-------
+pBufferOut can be null, in which case the call will act as a seek, and the return value will be the number of frames seeked.
+
+Note that this is lossy for streams where the bits per sample is larger than 16.
+*/
+DRFLAC_API drflac_uint64 drflac_read_pcm_frames_s16(drflac* pFlac, drflac_uint64 framesToRead, drflac_int16* pBufferOut);
+
+/*
+Reads sample data from the given FLAC decoder, output as interleaved 32-bit floating point PCM.
+
+
+Parameters
+----------
+pFlac (in)
+ The decoder.
+
+framesToRead (in)
+ The number of PCM frames to read.
+
+pBufferOut (out, optional)
+ A pointer to the buffer that will receive the decoded samples.
+
+
+Return Value
+------------
+Returns the number of PCM frames actually read. If the return value is less than `framesToRead` it has reached the end.
+
+
+Remarks
+-------
+pBufferOut can be null, in which case the call will act as a seek, and the return value will be the number of frames seeked.
+
+Note that this should be considered lossy due to the nature of floating point numbers not being able to exactly represent every possible number.
+*/
+DRFLAC_API drflac_uint64 drflac_read_pcm_frames_f32(drflac* pFlac, drflac_uint64 framesToRead, float* pBufferOut);
+
+/*
+Seeks to the PCM frame at the given index.
+
+
+Parameters
+----------
+pFlac (in)
+ The decoder.
+
+pcmFrameIndex (in)
+ The index of the PCM frame to seek to. See notes below.
+
+
+Return Value
+-------------
+`DRFLAC_TRUE` if successful; `DRFLAC_FALSE` otherwise.
+*/
+DRFLAC_API drflac_bool32 drflac_seek_to_pcm_frame(drflac* pFlac, drflac_uint64 pcmFrameIndex);
+
+
+
+#ifndef DR_FLAC_NO_STDIO
+/*
+Opens a FLAC decoder from the file at the given path.
+
+
+Parameters
+----------
+pFileName (in)
+ The path of the file to open, either absolute or relative to the current directory.
+
+pAllocationCallbacks (in, optional)
+ A pointer to application defined callbacks for managing memory allocations.
+
+
+Return Value
+------------
+A pointer to an object representing the decoder.
+
+
+Remarks
+-------
+Close the decoder with drflac_close().
+
+
+Remarks
+-------
+This will hold a handle to the file until the decoder is closed with drflac_close(). Some platforms will restrict the number of files a process can have open
+at any given time, so keep this mind if you have many decoders open at the same time.
+
+
+See Also
+--------
+drflac_open_file_with_metadata()
+drflac_open()
+drflac_close()
+*/
+DRFLAC_API drflac* drflac_open_file(const char* pFileName, const drflac_allocation_callbacks* pAllocationCallbacks);
+DRFLAC_API drflac* drflac_open_file_w(const wchar_t* pFileName, const drflac_allocation_callbacks* pAllocationCallbacks);
+
+/*
+Opens a FLAC decoder from the file at the given path and notifies the caller of the metadata chunks (album art, etc.)
+
+
+Parameters
+----------
+pFileName (in)
+ The path of the file to open, either absolute or relative to the current directory.
+
+pAllocationCallbacks (in, optional)
+ A pointer to application defined callbacks for managing memory allocations.
+
+onMeta (in)
+ The callback to fire for each metadata block.
+
+pUserData (in)
+ A pointer to the user data to pass to the metadata callback.
+
+pAllocationCallbacks (in)
+ A pointer to application defined callbacks for managing memory allocations.
+
+
+Remarks
+-------
+Look at the documentation for drflac_open_with_metadata() for more information on how metadata is handled.
+
+
+See Also
+--------
+drflac_open_with_metadata()
+drflac_open()
+drflac_close()
+*/
+DRFLAC_API drflac* drflac_open_file_with_metadata(const char* pFileName, drflac_meta_proc onMeta, void* pUserData, const drflac_allocation_callbacks* pAllocationCallbacks);
+DRFLAC_API drflac* drflac_open_file_with_metadata_w(const wchar_t* pFileName, drflac_meta_proc onMeta, void* pUserData, const drflac_allocation_callbacks* pAllocationCallbacks);
+#endif
+
+/*
+Opens a FLAC decoder from a pre-allocated block of memory
+
+
+Parameters
+----------
+pData (in)
+ A pointer to the raw encoded FLAC data.
+
+dataSize (in)
+ The size in bytes of `data`.
+
+pAllocationCallbacks (in)
+ A pointer to application defined callbacks for managing memory allocations.
+
+
+Return Value
+------------
+A pointer to an object representing the decoder.
+
+
+Remarks
+-------
+This does not create a copy of the data. It is up to the application to ensure the buffer remains valid for the lifetime of the decoder.
+
+
+See Also
+--------
+drflac_open()
+drflac_close()
+*/
+DRFLAC_API drflac* drflac_open_memory(const void* pData, size_t dataSize, const drflac_allocation_callbacks* pAllocationCallbacks);
+
+/*
+Opens a FLAC decoder from a pre-allocated block of memory and notifies the caller of the metadata chunks (album art, etc.)
+
+
+Parameters
+----------
+pData (in)
+ A pointer to the raw encoded FLAC data.
+
+dataSize (in)
+ The size in bytes of `data`.
+
+onMeta (in)
+ The callback to fire for each metadata block.
+
+pUserData (in)
+ A pointer to the user data to pass to the metadata callback.
+
+pAllocationCallbacks (in)
+ A pointer to application defined callbacks for managing memory allocations.
+
+
+Remarks
+-------
+Look at the documentation for drflac_open_with_metadata() for more information on how metadata is handled.
+
+
+See Also
+-------
+drflac_open_with_metadata()
+drflac_open()
+drflac_close()
+*/
+DRFLAC_API drflac* drflac_open_memory_with_metadata(const void* pData, size_t dataSize, drflac_meta_proc onMeta, void* pUserData, const drflac_allocation_callbacks* pAllocationCallbacks);
+
+
+
+/* High Level APIs */
+
+/*
+Opens a FLAC stream from the given callbacks and fully decodes it in a single operation. The return value is a
+pointer to the sample data as interleaved signed 32-bit PCM. The returned data must be freed with drflac_free().
+
+You can pass in custom memory allocation callbacks via the pAllocationCallbacks parameter. This can be NULL in which
+case it will use DRFLAC_MALLOC, DRFLAC_REALLOC and DRFLAC_FREE.
+
+Sometimes a FLAC file won't keep track of the total sample count. In this situation the function will continuously
+read samples into a dynamically sized buffer on the heap until no samples are left.
+
+Do not call this function on a broadcast type of stream (like internet radio streams and whatnot).
+*/
+DRFLAC_API drflac_int32* drflac_open_and_read_pcm_frames_s32(drflac_read_proc onRead, drflac_seek_proc onSeek, void* pUserData, unsigned int* channels, unsigned int* sampleRate, drflac_uint64* totalPCMFrameCount, const drflac_allocation_callbacks* pAllocationCallbacks);
+
+/* Same as drflac_open_and_read_pcm_frames_s32(), except returns signed 16-bit integer samples. */
+DRFLAC_API drflac_int16* drflac_open_and_read_pcm_frames_s16(drflac_read_proc onRead, drflac_seek_proc onSeek, void* pUserData, unsigned int* channels, unsigned int* sampleRate, drflac_uint64* totalPCMFrameCount, const drflac_allocation_callbacks* pAllocationCallbacks);
+
+/* Same as drflac_open_and_read_pcm_frames_s32(), except returns 32-bit floating-point samples. */
+DRFLAC_API float* drflac_open_and_read_pcm_frames_f32(drflac_read_proc onRead, drflac_seek_proc onSeek, void* pUserData, unsigned int* channels, unsigned int* sampleRate, drflac_uint64* totalPCMFrameCount, const drflac_allocation_callbacks* pAllocationCallbacks);
+
+#ifndef DR_FLAC_NO_STDIO
+/* Same as drflac_open_and_read_pcm_frames_s32() except opens the decoder from a file. */
+DRFLAC_API drflac_int32* drflac_open_file_and_read_pcm_frames_s32(const char* filename, unsigned int* channels, unsigned int* sampleRate, drflac_uint64* totalPCMFrameCount, const drflac_allocation_callbacks* pAllocationCallbacks);
+
+/* Same as drflac_open_file_and_read_pcm_frames_s32(), except returns signed 16-bit integer samples. */
+DRFLAC_API drflac_int16* drflac_open_file_and_read_pcm_frames_s16(const char* filename, unsigned int* channels, unsigned int* sampleRate, drflac_uint64* totalPCMFrameCount, const drflac_allocation_callbacks* pAllocationCallbacks);
+
+/* Same as drflac_open_file_and_read_pcm_frames_s32(), except returns 32-bit floating-point samples. */
+DRFLAC_API float* drflac_open_file_and_read_pcm_frames_f32(const char* filename, unsigned int* channels, unsigned int* sampleRate, drflac_uint64* totalPCMFrameCount, const drflac_allocation_callbacks* pAllocationCallbacks);
+#endif
+
+/* Same as drflac_open_and_read_pcm_frames_s32() except opens the decoder from a block of memory. */
+DRFLAC_API drflac_int32* drflac_open_memory_and_read_pcm_frames_s32(const void* data, size_t dataSize, unsigned int* channels, unsigned int* sampleRate, drflac_uint64* totalPCMFrameCount, const drflac_allocation_callbacks* pAllocationCallbacks);
+
+/* Same as drflac_open_memory_and_read_pcm_frames_s32(), except returns signed 16-bit integer samples. */
+DRFLAC_API drflac_int16* drflac_open_memory_and_read_pcm_frames_s16(const void* data, size_t dataSize, unsigned int* channels, unsigned int* sampleRate, drflac_uint64* totalPCMFrameCount, const drflac_allocation_callbacks* pAllocationCallbacks);
+
+/* Same as drflac_open_memory_and_read_pcm_frames_s32(), except returns 32-bit floating-point samples. */
+DRFLAC_API float* drflac_open_memory_and_read_pcm_frames_f32(const void* data, size_t dataSize, unsigned int* channels, unsigned int* sampleRate, drflac_uint64* totalPCMFrameCount, const drflac_allocation_callbacks* pAllocationCallbacks);
+
+/*
+Frees memory that was allocated internally by dr_flac.
+
+Set pAllocationCallbacks to the same object that was passed to drflac_open_*_and_read_pcm_frames_*(). If you originally passed in NULL, pass in NULL for this.
+*/
+DRFLAC_API void drflac_free(void* p, const drflac_allocation_callbacks* pAllocationCallbacks);
+
+
+/* Structure representing an iterator for vorbis comments in a VORBIS_COMMENT metadata block. */
+typedef struct
+{
+ drflac_uint32 countRemaining;
+ const char* pRunningData;
+} drflac_vorbis_comment_iterator;
+
+/*
+Initializes a vorbis comment iterator. This can be used for iterating over the vorbis comments in a VORBIS_COMMENT
+metadata block.
+*/
+DRFLAC_API void drflac_init_vorbis_comment_iterator(drflac_vorbis_comment_iterator* pIter, drflac_uint32 commentCount, const void* pComments);
+
+/*
+Goes to the next vorbis comment in the given iterator. If null is returned it means there are no more comments. The
+returned string is NOT null terminated.
+*/
+DRFLAC_API const char* drflac_next_vorbis_comment(drflac_vorbis_comment_iterator* pIter, drflac_uint32* pCommentLengthOut);
+
+
+/* Structure representing an iterator for cuesheet tracks in a CUESHEET metadata block. */
+typedef struct
+{
+ drflac_uint32 countRemaining;
+ const char* pRunningData;
+} drflac_cuesheet_track_iterator;
+
+/* The order of members here is important because we map this directly to the raw data within the CUESHEET metadata block. */
+typedef struct
+{
+ drflac_uint64 offset;
+ drflac_uint8 index;
+ drflac_uint8 reserved[3];
+} drflac_cuesheet_track_index;
+
+typedef struct
+{
+ drflac_uint64 offset;
+ drflac_uint8 trackNumber;
+ char ISRC[12];
+ drflac_bool8 isAudio;
+ drflac_bool8 preEmphasis;
+ drflac_uint8 indexCount;
+ const drflac_cuesheet_track_index* pIndexPoints;
+} drflac_cuesheet_track;
+
+/*
+Initializes a cuesheet track iterator. This can be used for iterating over the cuesheet tracks in a CUESHEET metadata
+block.
+*/
+DRFLAC_API void drflac_init_cuesheet_track_iterator(drflac_cuesheet_track_iterator* pIter, drflac_uint32 trackCount, const void* pTrackData);
+
+/* Goes to the next cuesheet track in the given iterator. If DRFLAC_FALSE is returned it means there are no more comments. */
+DRFLAC_API drflac_bool32 drflac_next_cuesheet_track(drflac_cuesheet_track_iterator* pIter, drflac_cuesheet_track* pCuesheetTrack);
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* dr_flac_h */
+
+
+/************************************************************************************************************************************************************
+ ************************************************************************************************************************************************************
+
+ IMPLEMENTATION
+
+ ************************************************************************************************************************************************************
+ ************************************************************************************************************************************************************/
+#if defined(DR_FLAC_IMPLEMENTATION) || defined(DRFLAC_IMPLEMENTATION)
+#ifndef dr_flac_c
+#define dr_flac_c
+
+/* Disable some annoying warnings. */
+#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))
+ #pragma GCC diagnostic push
+ #if __GNUC__ >= 7
+ #pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
+ #endif
+#endif
+
+#ifdef __linux__
+ #ifndef _BSD_SOURCE
+ #define _BSD_SOURCE
+ #endif
+ #ifndef _DEFAULT_SOURCE
+ #define _DEFAULT_SOURCE
+ #endif
+ #ifndef __USE_BSD
+ #define __USE_BSD
+ #endif
+ #include <endian.h>
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+
+/* Inline */
+#ifdef _MSC_VER
+ #define DRFLAC_INLINE __forceinline
+#elif defined(__GNUC__)
+ /*
+ I've had a bug report where GCC is emitting warnings about functions possibly not being inlineable. This warning happens when
+ the __attribute__((always_inline)) attribute is defined without an "inline" statement. I think therefore there must be some
+ case where "__inline__" is not always defined, thus the compiler emitting these warnings. When using -std=c89 or -ansi on the
+ command line, we cannot use the "inline" keyword and instead need to use "__inline__". In an attempt to work around this issue
+ I am using "__inline__" only when we're compiling in strict ANSI mode.
+ */
+ #if defined(__STRICT_ANSI__)
+ #define DRFLAC_GNUC_INLINE_HINT __inline__
+ #else
+ #define DRFLAC_GNUC_INLINE_HINT inline
+ #endif
+
+ #if (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 2)) || defined(__clang__)
+ #define DRFLAC_INLINE DRFLAC_GNUC_INLINE_HINT __attribute__((always_inline))
+ #else
+ #define DRFLAC_INLINE DRFLAC_GNUC_INLINE_HINT
+ #endif
+#elif defined(__WATCOMC__)
+ #define DRFLAC_INLINE __inline
+#else
+ #define DRFLAC_INLINE
+#endif
+/* End Inline */
+
+/*
+Intrinsics Support
+
+There's a bug in GCC 4.2.x which results in an incorrect compilation error when using _mm_slli_epi32() where it complains with
+
+ "error: shift must be an immediate"
+
+Unfortuantely dr_flac depends on this for a few things so we're just going to disable SSE on GCC 4.2 and below.
+*/
+#if !defined(DR_FLAC_NO_SIMD)
+ #if defined(DRFLAC_X64) || defined(DRFLAC_X86)
+ #if defined(_MSC_VER) && !defined(__clang__)
+ /* MSVC. */
+ #if _MSC_VER >= 1400 && !defined(DRFLAC_NO_SSE2) /* 2005 */
+ #define DRFLAC_SUPPORT_SSE2
+ #endif
+ #if _MSC_VER >= 1600 && !defined(DRFLAC_NO_SSE41) /* 2010 */
+ #define DRFLAC_SUPPORT_SSE41
+ #endif
+ #elif defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)))
+ /* Assume GNUC-style. */
+ #if defined(__SSE2__) && !defined(DRFLAC_NO_SSE2)
+ #define DRFLAC_SUPPORT_SSE2
+ #endif
+ #if defined(__SSE4_1__) && !defined(DRFLAC_NO_SSE41)
+ #define DRFLAC_SUPPORT_SSE41
+ #endif
+ #endif
+
+ /* If at this point we still haven't determined compiler support for the intrinsics just fall back to __has_include. */
+ #if !defined(__GNUC__) && !defined(__clang__) && defined(__has_include)
+ #if !defined(DRFLAC_SUPPORT_SSE2) && !defined(DRFLAC_NO_SSE2) && __has_include(<emmintrin.h>)
+ #define DRFLAC_SUPPORT_SSE2
+ #endif
+ #if !defined(DRFLAC_SUPPORT_SSE41) && !defined(DRFLAC_NO_SSE41) && __has_include(<smmintrin.h>)
+ #define DRFLAC_SUPPORT_SSE41
+ #endif
+ #endif
+
+ #if defined(DRFLAC_SUPPORT_SSE41)
+ #include <smmintrin.h>
+ #elif defined(DRFLAC_SUPPORT_SSE2)
+ #include <emmintrin.h>
+ #endif
+ #endif
+
+ #if defined(DRFLAC_ARM)
+ #if !defined(DRFLAC_NO_NEON) && (defined(__ARM_NEON) || defined(__aarch64__) || defined(_M_ARM64))
+ #define DRFLAC_SUPPORT_NEON
+ #include <arm_neon.h>
+ #endif
+ #endif
+#endif
+
+/* Compile-time CPU feature support. */
+#if !defined(DR_FLAC_NO_SIMD) && (defined(DRFLAC_X86) || defined(DRFLAC_X64))
+ #if defined(_MSC_VER) && !defined(__clang__)
+ #if _MSC_VER >= 1400
+ #include <intrin.h>
+ static void drflac__cpuid(int info[4], int fid)
+ {
+ __cpuid(info, fid);
+ }
+ #else
+ #define DRFLAC_NO_CPUID
+ #endif
+ #else
+ #if defined(__GNUC__) || defined(__clang__)
+ static void drflac__cpuid(int info[4], int fid)
+ {
+ /*
+ It looks like the -fPIC option uses the ebx register which GCC complains about. We can work around this by just using a different register, the
+ specific register of which I'm letting the compiler decide on. The "k" prefix is used to specify a 32-bit register. The {...} syntax is for
+ supporting different assembly dialects.
+
+ What's basically happening is that we're saving and restoring the ebx register manually.
+ */
+ #if defined(DRFLAC_X86) && defined(__PIC__)
+ __asm__ __volatile__ (
+ "xchg{l} {%%}ebx, %k1;"
+ "cpuid;"
+ "xchg{l} {%%}ebx, %k1;"
+ : "=a"(info[0]), "=&r"(info[1]), "=c"(info[2]), "=d"(info[3]) : "a"(fid), "c"(0)
+ );
+ #else
+ __asm__ __volatile__ (
+ "cpuid" : "=a"(info[0]), "=b"(info[1]), "=c"(info[2]), "=d"(info[3]) : "a"(fid), "c"(0)
+ );
+ #endif
+ }
+ #else
+ #define DRFLAC_NO_CPUID
+ #endif
+ #endif
+#else
+ #define DRFLAC_NO_CPUID
+#endif
+
+static DRFLAC_INLINE drflac_bool32 drflac_has_sse2(void)
+{
+#if defined(DRFLAC_SUPPORT_SSE2)
+ #if (defined(DRFLAC_X64) || defined(DRFLAC_X86)) && !defined(DRFLAC_NO_SSE2)
+ #if defined(DRFLAC_X64)
+ return DRFLAC_TRUE; /* 64-bit targets always support SSE2. */
+ #elif (defined(_M_IX86_FP) && _M_IX86_FP == 2) || defined(__SSE2__)
+ return DRFLAC_TRUE; /* If the compiler is allowed to freely generate SSE2 code we can assume support. */
+ #else
+ #if defined(DRFLAC_NO_CPUID)
+ return DRFLAC_FALSE;
+ #else
+ int info[4];
+ drflac__cpuid(info, 1);
+ return (info[3] & (1 << 26)) != 0;
+ #endif
+ #endif
+ #else
+ return DRFLAC_FALSE; /* SSE2 is only supported on x86 and x64 architectures. */
+ #endif
+#else
+ return DRFLAC_FALSE; /* No compiler support. */
+#endif
+}
+
+static DRFLAC_INLINE drflac_bool32 drflac_has_sse41(void)
+{
+#if defined(DRFLAC_SUPPORT_SSE41)
+ #if (defined(DRFLAC_X64) || defined(DRFLAC_X86)) && !defined(DRFLAC_NO_SSE41)
+ #if defined(__SSE4_1__) || defined(__AVX__)
+ return DRFLAC_TRUE; /* If the compiler is allowed to freely generate SSE41 code we can assume support. */
+ #else
+ #if defined(DRFLAC_NO_CPUID)
+ return DRFLAC_FALSE;
+ #else
+ int info[4];
+ drflac__cpuid(info, 1);
+ return (info[2] & (1 << 19)) != 0;
+ #endif
+ #endif
+ #else
+ return DRFLAC_FALSE; /* SSE41 is only supported on x86 and x64 architectures. */
+ #endif
+#else
+ return DRFLAC_FALSE; /* No compiler support. */
+#endif
+}
+
+
+#if defined(_MSC_VER) && _MSC_VER >= 1500 && (defined(DRFLAC_X86) || defined(DRFLAC_X64)) && !defined(__clang__)
+ #define DRFLAC_HAS_LZCNT_INTRINSIC
+#elif (defined(__GNUC__) && ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)))
+ #define DRFLAC_HAS_LZCNT_INTRINSIC
+#elif defined(__clang__)
+ #if defined(__has_builtin)
+ #if __has_builtin(__builtin_clzll) || __has_builtin(__builtin_clzl)
+ #define DRFLAC_HAS_LZCNT_INTRINSIC
+ #endif
+ #endif
+#endif
+
+#if defined(_MSC_VER) && _MSC_VER >= 1400 && !defined(__clang__)
+ #define DRFLAC_HAS_BYTESWAP16_INTRINSIC
+ #define DRFLAC_HAS_BYTESWAP32_INTRINSIC
+ #define DRFLAC_HAS_BYTESWAP64_INTRINSIC
+#elif defined(__clang__)
+ #if defined(__has_builtin)
+ #if __has_builtin(__builtin_bswap16)
+ #define DRFLAC_HAS_BYTESWAP16_INTRINSIC
+ #endif
+ #if __has_builtin(__builtin_bswap32)
+ #define DRFLAC_HAS_BYTESWAP32_INTRINSIC
+ #endif
+ #if __has_builtin(__builtin_bswap64)
+ #define DRFLAC_HAS_BYTESWAP64_INTRINSIC
+ #endif
+ #endif
+#elif defined(__GNUC__)
+ #if ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
+ #define DRFLAC_HAS_BYTESWAP32_INTRINSIC
+ #define DRFLAC_HAS_BYTESWAP64_INTRINSIC
+ #endif
+ #if ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8))
+ #define DRFLAC_HAS_BYTESWAP16_INTRINSIC
+ #endif
+#elif defined(__WATCOMC__) && defined(__386__)
+ #define DRFLAC_HAS_BYTESWAP16_INTRINSIC
+ #define DRFLAC_HAS_BYTESWAP32_INTRINSIC
+ #define DRFLAC_HAS_BYTESWAP64_INTRINSIC
+ extern __inline drflac_uint16 _watcom_bswap16(drflac_uint16);
+ extern __inline drflac_uint32 _watcom_bswap32(drflac_uint32);
+ extern __inline drflac_uint64 _watcom_bswap64(drflac_uint64);
+#pragma aux _watcom_bswap16 = \
+ "xchg al, ah" \
+ parm [ax] \
+ value [ax] \
+ modify nomemory;
+#pragma aux _watcom_bswap32 = \
+ "bswap eax" \
+ parm [eax] \
+ value [eax] \
+ modify nomemory;
+#pragma aux _watcom_bswap64 = \
+ "bswap eax" \
+ "bswap edx" \
+ "xchg eax,edx" \
+ parm [eax edx] \
+ value [eax edx] \
+ modify nomemory;
+#endif
+
+
+/* Standard library stuff. */
+#ifndef DRFLAC_ASSERT
+#include <assert.h>
+#define DRFLAC_ASSERT(expression) assert(expression)
+#endif
+#ifndef DRFLAC_MALLOC
+#define DRFLAC_MALLOC(sz) malloc((sz))
+#endif
+#ifndef DRFLAC_REALLOC
+#define DRFLAC_REALLOC(p, sz) realloc((p), (sz))
+#endif
+#ifndef DRFLAC_FREE
+#define DRFLAC_FREE(p) free((p))
+#endif
+#ifndef DRFLAC_COPY_MEMORY
+#define DRFLAC_COPY_MEMORY(dst, src, sz) memcpy((dst), (src), (sz))
+#endif
+#ifndef DRFLAC_ZERO_MEMORY
+#define DRFLAC_ZERO_MEMORY(p, sz) memset((p), 0, (sz))
+#endif
+#ifndef DRFLAC_ZERO_OBJECT
+#define DRFLAC_ZERO_OBJECT(p) DRFLAC_ZERO_MEMORY((p), sizeof(*(p)))
+#endif
+
+#define DRFLAC_MAX_SIMD_VECTOR_SIZE 64 /* 64 for AVX-512 in the future. */
+
+/* Result Codes */
+typedef drflac_int32 drflac_result;
+#define DRFLAC_SUCCESS 0
+#define DRFLAC_ERROR -1 /* A generic error. */
+#define DRFLAC_INVALID_ARGS -2
+#define DRFLAC_INVALID_OPERATION -3
+#define DRFLAC_OUT_OF_MEMORY -4
+#define DRFLAC_OUT_OF_RANGE -5
+#define DRFLAC_ACCESS_DENIED -6
+#define DRFLAC_DOES_NOT_EXIST -7
+#define DRFLAC_ALREADY_EXISTS -8
+#define DRFLAC_TOO_MANY_OPEN_FILES -9
+#define DRFLAC_INVALID_FILE -10
+#define DRFLAC_TOO_BIG -11
+#define DRFLAC_PATH_TOO_LONG -12
+#define DRFLAC_NAME_TOO_LONG -13
+#define DRFLAC_NOT_DIRECTORY -14
+#define DRFLAC_IS_DIRECTORY -15
+#define DRFLAC_DIRECTORY_NOT_EMPTY -16
+#define DRFLAC_END_OF_FILE -17
+#define DRFLAC_NO_SPACE -18
+#define DRFLAC_BUSY -19
+#define DRFLAC_IO_ERROR -20
+#define DRFLAC_INTERRUPT -21
+#define DRFLAC_UNAVAILABLE -22
+#define DRFLAC_ALREADY_IN_USE -23
+#define DRFLAC_BAD_ADDRESS -24
+#define DRFLAC_BAD_SEEK -25
+#define DRFLAC_BAD_PIPE -26
+#define DRFLAC_DEADLOCK -27
+#define DRFLAC_TOO_MANY_LINKS -28
+#define DRFLAC_NOT_IMPLEMENTED -29
+#define DRFLAC_NO_MESSAGE -30
+#define DRFLAC_BAD_MESSAGE -31
+#define DRFLAC_NO_DATA_AVAILABLE -32
+#define DRFLAC_INVALID_DATA -33
+#define DRFLAC_TIMEOUT -34
+#define DRFLAC_NO_NETWORK -35
+#define DRFLAC_NOT_UNIQUE -36
+#define DRFLAC_NOT_SOCKET -37
+#define DRFLAC_NO_ADDRESS -38
+#define DRFLAC_BAD_PROTOCOL -39
+#define DRFLAC_PROTOCOL_UNAVAILABLE -40
+#define DRFLAC_PROTOCOL_NOT_SUPPORTED -41
+#define DRFLAC_PROTOCOL_FAMILY_NOT_SUPPORTED -42
+#define DRFLAC_ADDRESS_FAMILY_NOT_SUPPORTED -43
+#define DRFLAC_SOCKET_NOT_SUPPORTED -44
+#define DRFLAC_CONNECTION_RESET -45
+#define DRFLAC_ALREADY_CONNECTED -46
+#define DRFLAC_NOT_CONNECTED -47
+#define DRFLAC_CONNECTION_REFUSED -48
+#define DRFLAC_NO_HOST -49
+#define DRFLAC_IN_PROGRESS -50
+#define DRFLAC_CANCELLED -51
+#define DRFLAC_MEMORY_ALREADY_MAPPED -52
+#define DRFLAC_AT_END -53
+
+#define DRFLAC_CRC_MISMATCH -100
+/* End Result Codes */
+
+
+#define DRFLAC_SUBFRAME_CONSTANT 0
+#define DRFLAC_SUBFRAME_VERBATIM 1
+#define DRFLAC_SUBFRAME_FIXED 8
+#define DRFLAC_SUBFRAME_LPC 32
+#define DRFLAC_SUBFRAME_RESERVED 255
+
+#define DRFLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE 0
+#define DRFLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE2 1
+
+#define DRFLAC_CHANNEL_ASSIGNMENT_INDEPENDENT 0
+#define DRFLAC_CHANNEL_ASSIGNMENT_LEFT_SIDE 8
+#define DRFLAC_CHANNEL_ASSIGNMENT_RIGHT_SIDE 9
+#define DRFLAC_CHANNEL_ASSIGNMENT_MID_SIDE 10
+
+#define DRFLAC_SEEKPOINT_SIZE_IN_BYTES 18
+#define DRFLAC_CUESHEET_TRACK_SIZE_IN_BYTES 36
+#define DRFLAC_CUESHEET_TRACK_INDEX_SIZE_IN_BYTES 12
+
+#define drflac_align(x, a) ((((x) + (a) - 1) / (a)) * (a))
+
+
+DRFLAC_API void drflac_version(drflac_uint32* pMajor, drflac_uint32* pMinor, drflac_uint32* pRevision)
+{
+ if (pMajor) {
+ *pMajor = DRFLAC_VERSION_MAJOR;
+ }
+
+ if (pMinor) {
+ *pMinor = DRFLAC_VERSION_MINOR;
+ }
+
+ if (pRevision) {
+ *pRevision = DRFLAC_VERSION_REVISION;
+ }
+}
+
+DRFLAC_API const char* drflac_version_string(void)
+{
+ return DRFLAC_VERSION_STRING;
+}
+
+
+/* CPU caps. */
+#if defined(__has_feature)
+ #if __has_feature(thread_sanitizer)
+ #define DRFLAC_NO_THREAD_SANITIZE __attribute__((no_sanitize("thread")))
+ #else
+ #define DRFLAC_NO_THREAD_SANITIZE
+ #endif
+#else
+ #define DRFLAC_NO_THREAD_SANITIZE
+#endif
+
+#if defined(DRFLAC_HAS_LZCNT_INTRINSIC)
+static drflac_bool32 drflac__gIsLZCNTSupported = DRFLAC_FALSE;
+#endif
+
+#ifndef DRFLAC_NO_CPUID
+static drflac_bool32 drflac__gIsSSE2Supported = DRFLAC_FALSE;
+static drflac_bool32 drflac__gIsSSE41Supported = DRFLAC_FALSE;
+
+/*
+I've had a bug report that Clang's ThreadSanitizer presents a warning in this function. Having reviewed this, this does
+actually make sense. However, since CPU caps should never differ for a running process, I don't think the trade off of
+complicating internal API's by passing around CPU caps versus just disabling the warnings is worthwhile. I'm therefore
+just going to disable these warnings. This is disabled via the DRFLAC_NO_THREAD_SANITIZE attribute.
+*/
+DRFLAC_NO_THREAD_SANITIZE static void drflac__init_cpu_caps(void)
+{
+ static drflac_bool32 isCPUCapsInitialized = DRFLAC_FALSE;
+
+ if (!isCPUCapsInitialized) {
+ /* LZCNT */
+#if defined(DRFLAC_HAS_LZCNT_INTRINSIC)
+ int info[4] = {0};
+ drflac__cpuid(info, 0x80000001);
+ drflac__gIsLZCNTSupported = (info[2] & (1 << 5)) != 0;
+#endif
+
+ /* SSE2 */
+ drflac__gIsSSE2Supported = drflac_has_sse2();
+
+ /* SSE4.1 */
+ drflac__gIsSSE41Supported = drflac_has_sse41();
+
+ /* Initialized. */
+ isCPUCapsInitialized = DRFLAC_TRUE;
+ }
+}
+#else
+static drflac_bool32 drflac__gIsNEONSupported = DRFLAC_FALSE;
+
+static DRFLAC_INLINE drflac_bool32 drflac__has_neon(void)
+{
+#if defined(DRFLAC_SUPPORT_NEON)
+ #if defined(DRFLAC_ARM) && !defined(DRFLAC_NO_NEON)
+ #if (defined(__ARM_NEON) || defined(__aarch64__) || defined(_M_ARM64))
+ return DRFLAC_TRUE; /* If the compiler is allowed to freely generate NEON code we can assume support. */
+ #else
+ /* TODO: Runtime check. */
+ return DRFLAC_FALSE;
+ #endif
+ #else
+ return DRFLAC_FALSE; /* NEON is only supported on ARM architectures. */
+ #endif
+#else
+ return DRFLAC_FALSE; /* No compiler support. */
+#endif
+}
+
+DRFLAC_NO_THREAD_SANITIZE static void drflac__init_cpu_caps(void)
+{
+ drflac__gIsNEONSupported = drflac__has_neon();
+
+#if defined(DRFLAC_HAS_LZCNT_INTRINSIC) && defined(DRFLAC_ARM) && (defined(__ARM_ARCH) && __ARM_ARCH >= 5)
+ drflac__gIsLZCNTSupported = DRFLAC_TRUE;
+#endif
+}
+#endif
+
+
+/* Endian Management */
+static DRFLAC_INLINE drflac_bool32 drflac__is_little_endian(void)
+{
+#if defined(DRFLAC_X86) || defined(DRFLAC_X64)
+ return DRFLAC_TRUE;
+#elif defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && __BYTE_ORDER == __LITTLE_ENDIAN
+ return DRFLAC_TRUE;
+#else
+ int n = 1;
+ return (*(char*)&n) == 1;
+#endif
+}
+
+static DRFLAC_INLINE drflac_uint16 drflac__swap_endian_uint16(drflac_uint16 n)
+{
+#ifdef DRFLAC_HAS_BYTESWAP16_INTRINSIC
+ #if defined(_MSC_VER) && !defined(__clang__)
+ return _byteswap_ushort(n);
+ #elif defined(__GNUC__) || defined(__clang__)
+ return __builtin_bswap16(n);
+ #elif defined(__WATCOMC__) && defined(__386__)
+ return _watcom_bswap16(n);
+ #else
+ #error "This compiler does not support the byte swap intrinsic."
+ #endif
+#else
+ return ((n & 0xFF00) >> 8) |
+ ((n & 0x00FF) << 8);
+#endif
+}
+
+static DRFLAC_INLINE drflac_uint32 drflac__swap_endian_uint32(drflac_uint32 n)
+{
+#ifdef DRFLAC_HAS_BYTESWAP32_INTRINSIC
+ #if defined(_MSC_VER) && !defined(__clang__)
+ return _byteswap_ulong(n);
+ #elif defined(__GNUC__) || defined(__clang__)
+ #if defined(DRFLAC_ARM) && (defined(__ARM_ARCH) && __ARM_ARCH >= 6) && !defined(__ARM_ARCH_6M__) && !defined(DRFLAC_64BIT) /* <-- 64-bit inline assembly has not been tested, so disabling for now. */
+ /* Inline assembly optimized implementation for ARM. In my testing, GCC does not generate optimized code with __builtin_bswap32(). */
+ drflac_uint32 r;
+ __asm__ __volatile__ (
+ #if defined(DRFLAC_64BIT)
+ "rev %w[out], %w[in]" : [out]"=r"(r) : [in]"r"(n) /* <-- This is untested. If someone in the community could test this, that would be appreciated! */
+ #else
+ "rev %[out], %[in]" : [out]"=r"(r) : [in]"r"(n)
+ #endif
+ );
+ return r;
+ #else
+ return __builtin_bswap32(n);
+ #endif
+ #elif defined(__WATCOMC__) && defined(__386__)
+ return _watcom_bswap32(n);
+ #else
+ #error "This compiler does not support the byte swap intrinsic."
+ #endif
+#else
+ return ((n & 0xFF000000) >> 24) |
+ ((n & 0x00FF0000) >> 8) |
+ ((n & 0x0000FF00) << 8) |
+ ((n & 0x000000FF) << 24);
+#endif
+}
+
+static DRFLAC_INLINE drflac_uint64 drflac__swap_endian_uint64(drflac_uint64 n)
+{
+#ifdef DRFLAC_HAS_BYTESWAP64_INTRINSIC
+ #if defined(_MSC_VER) && !defined(__clang__)
+ return _byteswap_uint64(n);
+ #elif defined(__GNUC__) || defined(__clang__)
+ return __builtin_bswap64(n);
+ #elif defined(__WATCOMC__) && defined(__386__)
+ return _watcom_bswap64(n);
+ #else
+ #error "This compiler does not support the byte swap intrinsic."
+ #endif
+#else
+ /* Weird "<< 32" bitshift is required for C89 because it doesn't support 64-bit constants. Should be optimized out by a good compiler. */
+ return ((n & ((drflac_uint64)0xFF000000 << 32)) >> 56) |
+ ((n & ((drflac_uint64)0x00FF0000 << 32)) >> 40) |
+ ((n & ((drflac_uint64)0x0000FF00 << 32)) >> 24) |
+ ((n & ((drflac_uint64)0x000000FF << 32)) >> 8) |
+ ((n & ((drflac_uint64)0xFF000000 )) << 8) |
+ ((n & ((drflac_uint64)0x00FF0000 )) << 24) |
+ ((n & ((drflac_uint64)0x0000FF00 )) << 40) |
+ ((n & ((drflac_uint64)0x000000FF )) << 56);
+#endif
+}
+
+
+static DRFLAC_INLINE drflac_uint16 drflac__be2host_16(drflac_uint16 n)
+{
+ if (drflac__is_little_endian()) {
+ return drflac__swap_endian_uint16(n);
+ }
+
+ return n;
+}
+
+static DRFLAC_INLINE drflac_uint32 drflac__be2host_32(drflac_uint32 n)
+{
+ if (drflac__is_little_endian()) {
+ return drflac__swap_endian_uint32(n);
+ }
+
+ return n;
+}
+
+static DRFLAC_INLINE drflac_uint32 drflac__be2host_32_ptr_unaligned(const void* pData)
+{
+ const drflac_uint8* pNum = (drflac_uint8*)pData;
+ return *(pNum) << 24 | *(pNum+1) << 16 | *(pNum+2) << 8 | *(pNum+3);
+}
+
+static DRFLAC_INLINE drflac_uint64 drflac__be2host_64(drflac_uint64 n)
+{
+ if (drflac__is_little_endian()) {
+ return drflac__swap_endian_uint64(n);
+ }
+
+ return n;
+}
+
+
+static DRFLAC_INLINE drflac_uint32 drflac__le2host_32(drflac_uint32 n)
+{
+ if (!drflac__is_little_endian()) {
+ return drflac__swap_endian_uint32(n);
+ }
+
+ return n;
+}
+
+static DRFLAC_INLINE drflac_uint32 drflac__le2host_32_ptr_unaligned(const void* pData)
+{
+ const drflac_uint8* pNum = (drflac_uint8*)pData;
+ return *pNum | *(pNum+1) << 8 | *(pNum+2) << 16 | *(pNum+3) << 24;
+}
+
+
+static DRFLAC_INLINE drflac_uint32 drflac__unsynchsafe_32(drflac_uint32 n)
+{
+ drflac_uint32 result = 0;
+ result |= (n & 0x7F000000) >> 3;
+ result |= (n & 0x007F0000) >> 2;
+ result |= (n & 0x00007F00) >> 1;
+ result |= (n & 0x0000007F) >> 0;
+
+ return result;
+}
+
+
+
+/* The CRC code below is based on this document: http://zlib.net/crc_v3.txt */
+static drflac_uint8 drflac__crc8_table[] = {
+ 0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15, 0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
+ 0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65, 0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
+ 0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5, 0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
+ 0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85, 0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
+ 0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2, 0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
+ 0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2, 0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
+ 0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32, 0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
+ 0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42, 0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
+ 0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C, 0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
+ 0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC, 0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
+ 0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C, 0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
+ 0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C, 0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
+ 0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B, 0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
+ 0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B, 0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
+ 0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB, 0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
+ 0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB, 0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
+};
+
+static drflac_uint16 drflac__crc16_table[] = {
+ 0x0000, 0x8005, 0x800F, 0x000A, 0x801B, 0x001E, 0x0014, 0x8011,
+ 0x8033, 0x0036, 0x003C, 0x8039, 0x0028, 0x802D, 0x8027, 0x0022,
+ 0x8063, 0x0066, 0x006C, 0x8069, 0x0078, 0x807D, 0x8077, 0x0072,
+ 0x0050, 0x8055, 0x805F, 0x005A, 0x804B, 0x004E, 0x0044, 0x8041,
+ 0x80C3, 0x00C6, 0x00CC, 0x80C9, 0x00D8, 0x80DD, 0x80D7, 0x00D2,
+ 0x00F0, 0x80F5, 0x80FF, 0x00FA, 0x80EB, 0x00EE, 0x00E4, 0x80E1,
+ 0x00A0, 0x80A5, 0x80AF, 0x00AA, 0x80BB, 0x00BE, 0x00B4, 0x80B1,
+ 0x8093, 0x0096, 0x009C, 0x8099, 0x0088, 0x808D, 0x8087, 0x0082,
+ 0x8183, 0x0186, 0x018C, 0x8189, 0x0198, 0x819D, 0x8197, 0x0192,
+ 0x01B0, 0x81B5, 0x81BF, 0x01BA, 0x81AB, 0x01AE, 0x01A4, 0x81A1,
+ 0x01E0, 0x81E5, 0x81EF, 0x01EA, 0x81FB, 0x01FE, 0x01F4, 0x81F1,
+ 0x81D3, 0x01D6, 0x01DC, 0x81D9, 0x01C8, 0x81CD, 0x81C7, 0x01C2,
+ 0x0140, 0x8145, 0x814F, 0x014A, 0x815B, 0x015E, 0x0154, 0x8151,
+ 0x8173, 0x0176, 0x017C, 0x8179, 0x0168, 0x816D, 0x8167, 0x0162,
+ 0x8123, 0x0126, 0x012C, 0x8129, 0x0138, 0x813D, 0x8137, 0x0132,
+ 0x0110, 0x8115, 0x811F, 0x011A, 0x810B, 0x010E, 0x0104, 0x8101,
+ 0x8303, 0x0306, 0x030C, 0x8309, 0x0318, 0x831D, 0x8317, 0x0312,
+ 0x0330, 0x8335, 0x833F, 0x033A, 0x832B, 0x032E, 0x0324, 0x8321,
+ 0x0360, 0x8365, 0x836F, 0x036A, 0x837B, 0x037E, 0x0374, 0x8371,
+ 0x8353, 0x0356, 0x035C, 0x8359, 0x0348, 0x834D, 0x8347, 0x0342,
+ 0x03C0, 0x83C5, 0x83CF, 0x03CA, 0x83DB, 0x03DE, 0x03D4, 0x83D1,
+ 0x83F3, 0x03F6, 0x03FC, 0x83F9, 0x03E8, 0x83ED, 0x83E7, 0x03E2,
+ 0x83A3, 0x03A6, 0x03AC, 0x83A9, 0x03B8, 0x83BD, 0x83B7, 0x03B2,
+ 0x0390, 0x8395, 0x839F, 0x039A, 0x838B, 0x038E, 0x0384, 0x8381,
+ 0x0280, 0x8285, 0x828F, 0x028A, 0x829B, 0x029E, 0x0294, 0x8291,
+ 0x82B3, 0x02B6, 0x02BC, 0x82B9, 0x02A8, 0x82AD, 0x82A7, 0x02A2,
+ 0x82E3, 0x02E6, 0x02EC, 0x82E9, 0x02F8, 0x82FD, 0x82F7, 0x02F2,
+ 0x02D0, 0x82D5, 0x82DF, 0x02DA, 0x82CB, 0x02CE, 0x02C4, 0x82C1,
+ 0x8243, 0x0246, 0x024C, 0x8249, 0x0258, 0x825D, 0x8257, 0x0252,
+ 0x0270, 0x8275, 0x827F, 0x027A, 0x826B, 0x026E, 0x0264, 0x8261,
+ 0x0220, 0x8225, 0x822F, 0x022A, 0x823B, 0x023E, 0x0234, 0x8231,
+ 0x8213, 0x0216, 0x021C, 0x8219, 0x0208, 0x820D, 0x8207, 0x0202
+};
+
+static DRFLAC_INLINE drflac_uint8 drflac_crc8_byte(drflac_uint8 crc, drflac_uint8 data)
+{
+ return drflac__crc8_table[crc ^ data];
+}
+
+static DRFLAC_INLINE drflac_uint8 drflac_crc8(drflac_uint8 crc, drflac_uint32 data, drflac_uint32 count)
+{
+#ifdef DR_FLAC_NO_CRC
+ (void)crc;
+ (void)data;
+ (void)count;
+ return 0;
+#else
+#if 0
+ /* REFERENCE (use of this implementation requires an explicit flush by doing "drflac_crc8(crc, 0, 8);") */
+ drflac_uint8 p = 0x07;
+ for (int i = count-1; i >= 0; --i) {
+ drflac_uint8 bit = (data & (1 << i)) >> i;
+ if (crc & 0x80) {
+ crc = ((crc << 1) | bit) ^ p;
+ } else {
+ crc = ((crc << 1) | bit);
+ }
+ }
+ return crc;
+#else
+ drflac_uint32 wholeBytes;
+ drflac_uint32 leftoverBits;
+ drflac_uint64 leftoverDataMask;
+
+ static drflac_uint64 leftoverDataMaskTable[8] = {
+ 0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F
+ };
+
+ DRFLAC_ASSERT(count <= 32);
+
+ wholeBytes = count >> 3;
+ leftoverBits = count - (wholeBytes*8);
+ leftoverDataMask = leftoverDataMaskTable[leftoverBits];
+
+ switch (wholeBytes) {
+ case 4: crc = drflac_crc8_byte(crc, (drflac_uint8)((data & (0xFF000000UL << leftoverBits)) >> (24 + leftoverBits)));
+ case 3: crc = drflac_crc8_byte(crc, (drflac_uint8)((data & (0x00FF0000UL << leftoverBits)) >> (16 + leftoverBits)));
+ case 2: crc = drflac_crc8_byte(crc, (drflac_uint8)((data & (0x0000FF00UL << leftoverBits)) >> ( 8 + leftoverBits)));
+ case 1: crc = drflac_crc8_byte(crc, (drflac_uint8)((data & (0x000000FFUL << leftoverBits)) >> ( 0 + leftoverBits)));
+ case 0: if (leftoverBits > 0) crc = (drflac_uint8)((crc << leftoverBits) ^ drflac__crc8_table[(crc >> (8 - leftoverBits)) ^ (data & leftoverDataMask)]);
+ }
+ return crc;
+#endif
+#endif
+}
+
+static DRFLAC_INLINE drflac_uint16 drflac_crc16_byte(drflac_uint16 crc, drflac_uint8 data)
+{
+ return (crc << 8) ^ drflac__crc16_table[(drflac_uint8)(crc >> 8) ^ data];
+}
+
+static DRFLAC_INLINE drflac_uint16 drflac_crc16_cache(drflac_uint16 crc, drflac_cache_t data)
+{
+#ifdef DRFLAC_64BIT
+ crc = drflac_crc16_byte(crc, (drflac_uint8)((data >> 56) & 0xFF));
+ crc = drflac_crc16_byte(crc, (drflac_uint8)((data >> 48) & 0xFF));
+ crc = drflac_crc16_byte(crc, (drflac_uint8)((data >> 40) & 0xFF));
+ crc = drflac_crc16_byte(crc, (drflac_uint8)((data >> 32) & 0xFF));
+#endif
+ crc = drflac_crc16_byte(crc, (drflac_uint8)((data >> 24) & 0xFF));
+ crc = drflac_crc16_byte(crc, (drflac_uint8)((data >> 16) & 0xFF));
+ crc = drflac_crc16_byte(crc, (drflac_uint8)((data >> 8) & 0xFF));
+ crc = drflac_crc16_byte(crc, (drflac_uint8)((data >> 0) & 0xFF));
+
+ return crc;
+}
+
+static DRFLAC_INLINE drflac_uint16 drflac_crc16_bytes(drflac_uint16 crc, drflac_cache_t data, drflac_uint32 byteCount)
+{
+ switch (byteCount)
+ {
+#ifdef DRFLAC_64BIT
+ case 8: crc = drflac_crc16_byte(crc, (drflac_uint8)((data >> 56) & 0xFF));
+ case 7: crc = drflac_crc16_byte(crc, (drflac_uint8)((data >> 48) & 0xFF));
+ case 6: crc = drflac_crc16_byte(crc, (drflac_uint8)((data >> 40) & 0xFF));
+ case 5: crc = drflac_crc16_byte(crc, (drflac_uint8)((data >> 32) & 0xFF));
+#endif
+ case 4: crc = drflac_crc16_byte(crc, (drflac_uint8)((data >> 24) & 0xFF));
+ case 3: crc = drflac_crc16_byte(crc, (drflac_uint8)((data >> 16) & 0xFF));
+ case 2: crc = drflac_crc16_byte(crc, (drflac_uint8)((data >> 8) & 0xFF));
+ case 1: crc = drflac_crc16_byte(crc, (drflac_uint8)((data >> 0) & 0xFF));
+ }
+
+ return crc;
+}
+
+#if 0
+static DRFLAC_INLINE drflac_uint16 drflac_crc16__32bit(drflac_uint16 crc, drflac_uint32 data, drflac_uint32 count)
+{
+#ifdef DR_FLAC_NO_CRC
+ (void)crc;
+ (void)data;
+ (void)count;
+ return 0;
+#else
+#if 0
+ /* REFERENCE (use of this implementation requires an explicit flush by doing "drflac_crc16(crc, 0, 16);") */
+ drflac_uint16 p = 0x8005;
+ for (int i = count-1; i >= 0; --i) {
+ drflac_uint16 bit = (data & (1ULL << i)) >> i;
+ if (r & 0x8000) {
+ r = ((r << 1) | bit) ^ p;
+ } else {
+ r = ((r << 1) | bit);
+ }
+ }
+
+ return crc;
+#else
+ drflac_uint32 wholeBytes;
+ drflac_uint32 leftoverBits;
+ drflac_uint64 leftoverDataMask;
+
+ static drflac_uint64 leftoverDataMaskTable[8] = {
+ 0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F
+ };
+
+ DRFLAC_ASSERT(count <= 64);
+
+ wholeBytes = count >> 3;
+ leftoverBits = count & 7;
+ leftoverDataMask = leftoverDataMaskTable[leftoverBits];
+
+ switch (wholeBytes) {
+ default:
+ case 4: crc = drflac_crc16_byte(crc, (drflac_uint8)((data & (0xFF000000UL << leftoverBits)) >> (24 + leftoverBits)));
+ case 3: crc = drflac_crc16_byte(crc, (drflac_uint8)((data & (0x00FF0000UL << leftoverBits)) >> (16 + leftoverBits)));
+ case 2: crc = drflac_crc16_byte(crc, (drflac_uint8)((data & (0x0000FF00UL << leftoverBits)) >> ( 8 + leftoverBits)));
+ case 1: crc = drflac_crc16_byte(crc, (drflac_uint8)((data & (0x000000FFUL << leftoverBits)) >> ( 0 + leftoverBits)));
+ case 0: if (leftoverBits > 0) crc = (crc << leftoverBits) ^ drflac__crc16_table[(crc >> (16 - leftoverBits)) ^ (data & leftoverDataMask)];
+ }
+ return crc;
+#endif
+#endif
+}
+
+static DRFLAC_INLINE drflac_uint16 drflac_crc16__64bit(drflac_uint16 crc, drflac_uint64 data, drflac_uint32 count)
+{
+#ifdef DR_FLAC_NO_CRC
+ (void)crc;
+ (void)data;
+ (void)count;
+ return 0;
+#else
+ drflac_uint32 wholeBytes;
+ drflac_uint32 leftoverBits;
+ drflac_uint64 leftoverDataMask;
+
+ static drflac_uint64 leftoverDataMaskTable[8] = {
+ 0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F
+ };
+
+ DRFLAC_ASSERT(count <= 64);
+
+ wholeBytes = count >> 3;
+ leftoverBits = count & 7;
+ leftoverDataMask = leftoverDataMaskTable[leftoverBits];
+
+ switch (wholeBytes) {
+ default:
+ case 8: crc = drflac_crc16_byte(crc, (drflac_uint8)((data & (((drflac_uint64)0xFF000000 << 32) << leftoverBits)) >> (56 + leftoverBits))); /* Weird "<< 32" bitshift is required for C89 because it doesn't support 64-bit constants. Should be optimized out by a good compiler. */
+ case 7: crc = drflac_crc16_byte(crc, (drflac_uint8)((data & (((drflac_uint64)0x00FF0000 << 32) << leftoverBits)) >> (48 + leftoverBits)));
+ case 6: crc = drflac_crc16_byte(crc, (drflac_uint8)((data & (((drflac_uint64)0x0000FF00 << 32) << leftoverBits)) >> (40 + leftoverBits)));
+ case 5: crc = drflac_crc16_byte(crc, (drflac_uint8)((data & (((drflac_uint64)0x000000FF << 32) << leftoverBits)) >> (32 + leftoverBits)));
+ case 4: crc = drflac_crc16_byte(crc, (drflac_uint8)((data & (((drflac_uint64)0xFF000000 ) << leftoverBits)) >> (24 + leftoverBits)));
+ case 3: crc = drflac_crc16_byte(crc, (drflac_uint8)((data & (((drflac_uint64)0x00FF0000 ) << leftoverBits)) >> (16 + leftoverBits)));
+ case 2: crc = drflac_crc16_byte(crc, (drflac_uint8)((data & (((drflac_uint64)0x0000FF00 ) << leftoverBits)) >> ( 8 + leftoverBits)));
+ case 1: crc = drflac_crc16_byte(crc, (drflac_uint8)((data & (((drflac_uint64)0x000000FF ) << leftoverBits)) >> ( 0 + leftoverBits)));
+ case 0: if (leftoverBits > 0) crc = (crc << leftoverBits) ^ drflac__crc16_table[(crc >> (16 - leftoverBits)) ^ (data & leftoverDataMask)];
+ }
+ return crc;
+#endif
+}
+
+
+static DRFLAC_INLINE drflac_uint16 drflac_crc16(drflac_uint16 crc, drflac_cache_t data, drflac_uint32 count)
+{
+#ifdef DRFLAC_64BIT
+ return drflac_crc16__64bit(crc, data, count);
+#else
+ return drflac_crc16__32bit(crc, data, count);
+#endif
+}
+#endif
+
+
+#ifdef DRFLAC_64BIT
+#define drflac__be2host__cache_line drflac__be2host_64
+#else
+#define drflac__be2host__cache_line drflac__be2host_32
+#endif
+
+/*
+BIT READING ATTEMPT #2
+
+This uses a 32- or 64-bit bit-shifted cache - as bits are read, the cache is shifted such that the first valid bit is sitting
+on the most significant bit. It uses the notion of an L1 and L2 cache (borrowed from CPU architecture), where the L1 cache
+is a 32- or 64-bit unsigned integer (depending on whether or not a 32- or 64-bit build is being compiled) and the L2 is an
+array of "cache lines", with each cache line being the same size as the L1. The L2 is a buffer of about 4KB and is where data
+from onRead() is read into.
+*/
+#define DRFLAC_CACHE_L1_SIZE_BYTES(bs) (sizeof((bs)->cache))
+#define DRFLAC_CACHE_L1_SIZE_BITS(bs) (sizeof((bs)->cache)*8)
+#define DRFLAC_CACHE_L1_BITS_REMAINING(bs) (DRFLAC_CACHE_L1_SIZE_BITS(bs) - (bs)->consumedBits)
+#define DRFLAC_CACHE_L1_SELECTION_MASK(_bitCount) (~((~(drflac_cache_t)0) >> (_bitCount)))
+#define DRFLAC_CACHE_L1_SELECTION_SHIFT(bs, _bitCount) (DRFLAC_CACHE_L1_SIZE_BITS(bs) - (_bitCount))
+#define DRFLAC_CACHE_L1_SELECT(bs, _bitCount) (((bs)->cache) & DRFLAC_CACHE_L1_SELECTION_MASK(_bitCount))
+#define DRFLAC_CACHE_L1_SELECT_AND_SHIFT(bs, _bitCount) (DRFLAC_CACHE_L1_SELECT((bs), (_bitCount)) >> DRFLAC_CACHE_L1_SELECTION_SHIFT((bs), (_bitCount)))
+#define DRFLAC_CACHE_L1_SELECT_AND_SHIFT_SAFE(bs, _bitCount)(DRFLAC_CACHE_L1_SELECT((bs), (_bitCount)) >> (DRFLAC_CACHE_L1_SELECTION_SHIFT((bs), (_bitCount)) & (DRFLAC_CACHE_L1_SIZE_BITS(bs)-1)))
+#define DRFLAC_CACHE_L2_SIZE_BYTES(bs) (sizeof((bs)->cacheL2))
+#define DRFLAC_CACHE_L2_LINE_COUNT(bs) (DRFLAC_CACHE_L2_SIZE_BYTES(bs) / sizeof((bs)->cacheL2[0]))
+#define DRFLAC_CACHE_L2_LINES_REMAINING(bs) (DRFLAC_CACHE_L2_LINE_COUNT(bs) - (bs)->nextL2Line)
+
+
+#ifndef DR_FLAC_NO_CRC
+static DRFLAC_INLINE void drflac__reset_crc16(drflac_bs* bs)
+{
+ bs->crc16 = 0;
+ bs->crc16CacheIgnoredBytes = bs->consumedBits >> 3;
+}
+
+static DRFLAC_INLINE void drflac__update_crc16(drflac_bs* bs)
+{
+ if (bs->crc16CacheIgnoredBytes == 0) {
+ bs->crc16 = drflac_crc16_cache(bs->crc16, bs->crc16Cache);
+ } else {
+ bs->crc16 = drflac_crc16_bytes(bs->crc16, bs->crc16Cache, DRFLAC_CACHE_L1_SIZE_BYTES(bs) - bs->crc16CacheIgnoredBytes);
+ bs->crc16CacheIgnoredBytes = 0;
+ }
+}
+
+static DRFLAC_INLINE drflac_uint16 drflac__flush_crc16(drflac_bs* bs)
+{
+ /* We should never be flushing in a situation where we are not aligned on a byte boundary. */
+ DRFLAC_ASSERT((DRFLAC_CACHE_L1_BITS_REMAINING(bs) & 7) == 0);
+
+ /*
+ The bits that were read from the L1 cache need to be accumulated. The number of bytes needing to be accumulated is determined
+ by the number of bits that have been consumed.
+ */
+ if (DRFLAC_CACHE_L1_BITS_REMAINING(bs) == 0) {
+ drflac__update_crc16(bs);
+ } else {
+ /* We only accumulate the consumed bits. */
+ bs->crc16 = drflac_crc16_bytes(bs->crc16, bs->crc16Cache >> DRFLAC_CACHE_L1_BITS_REMAINING(bs), (bs->consumedBits >> 3) - bs->crc16CacheIgnoredBytes);
+
+ /*
+ The bits that we just accumulated should never be accumulated again. We need to keep track of how many bytes were accumulated
+ so we can handle that later.
+ */
+ bs->crc16CacheIgnoredBytes = bs->consumedBits >> 3;
+ }
+
+ return bs->crc16;
+}
+#endif
+
+static DRFLAC_INLINE drflac_bool32 drflac__reload_l1_cache_from_l2(drflac_bs* bs)
+{
+ size_t bytesRead;
+ size_t alignedL1LineCount;
+
+ /* Fast path. Try loading straight from L2. */
+ if (bs->nextL2Line < DRFLAC_CACHE_L2_LINE_COUNT(bs)) {
+ bs->cache = bs->cacheL2[bs->nextL2Line++];
+ return DRFLAC_TRUE;
+ }
+
+ /*
+ If we get here it means we've run out of data in the L2 cache. We'll need to fetch more from the client, if there's
+ any left.
+ */
+ if (bs->unalignedByteCount > 0) {
+ return DRFLAC_FALSE; /* If we have any unaligned bytes it means there's no more aligned bytes left in the client. */
+ }
+
+ bytesRead = bs->onRead(bs->pUserData, bs->cacheL2, DRFLAC_CACHE_L2_SIZE_BYTES(bs));
+
+ bs->nextL2Line = 0;
+ if (bytesRead == DRFLAC_CACHE_L2_SIZE_BYTES(bs)) {
+ bs->cache = bs->cacheL2[bs->nextL2Line++];
+ return DRFLAC_TRUE;
+ }
+
+
+ /*
+ If we get here it means we were unable to retrieve enough data to fill the entire L2 cache. It probably
+ means we've just reached the end of the file. We need to move the valid data down to the end of the buffer
+ and adjust the index of the next line accordingly. Also keep in mind that the L2 cache must be aligned to
+ the size of the L1 so we'll need to seek backwards by any misaligned bytes.
+ */
+ alignedL1LineCount = bytesRead / DRFLAC_CACHE_L1_SIZE_BYTES(bs);
+
+ /* We need to keep track of any unaligned bytes for later use. */
+ bs->unalignedByteCount = bytesRead - (alignedL1LineCount * DRFLAC_CACHE_L1_SIZE_BYTES(bs));
+ if (bs->unalignedByteCount > 0) {
+ bs->unalignedCache = bs->cacheL2[alignedL1LineCount];
+ }
+
+ if (alignedL1LineCount > 0) {
+ size_t offset = DRFLAC_CACHE_L2_LINE_COUNT(bs) - alignedL1LineCount;
+ size_t i;
+ for (i = alignedL1LineCount; i > 0; --i) {
+ bs->cacheL2[i-1 + offset] = bs->cacheL2[i-1];
+ }
+
+ bs->nextL2Line = (drflac_uint32)offset;
+ bs->cache = bs->cacheL2[bs->nextL2Line++];
+ return DRFLAC_TRUE;
+ } else {
+ /* If we get into this branch it means we weren't able to load any L1-aligned data. */
+ bs->nextL2Line = DRFLAC_CACHE_L2_LINE_COUNT(bs);
+ return DRFLAC_FALSE;
+ }
+}
+
+static drflac_bool32 drflac__reload_cache(drflac_bs* bs)
+{
+ size_t bytesRead;
+
+#ifndef DR_FLAC_NO_CRC
+ drflac__update_crc16(bs);
+#endif
+
+ /* Fast path. Try just moving the next value in the L2 cache to the L1 cache. */
+ if (drflac__reload_l1_cache_from_l2(bs)) {
+ bs->cache = drflac__be2host__cache_line(bs->cache);
+ bs->consumedBits = 0;
+#ifndef DR_FLAC_NO_CRC
+ bs->crc16Cache = bs->cache;
+#endif
+ return DRFLAC_TRUE;
+ }
+
+ /* Slow path. */
+
+ /*
+ If we get here it means we have failed to load the L1 cache from the L2. Likely we've just reached the end of the stream and the last
+ few bytes did not meet the alignment requirements for the L2 cache. In this case we need to fall back to a slower path and read the
+ data from the unaligned cache.
+ */
+ bytesRead = bs->unalignedByteCount;
+ if (bytesRead == 0) {
+ bs->consumedBits = DRFLAC_CACHE_L1_SIZE_BITS(bs); /* <-- The stream has been exhausted, so marked the bits as consumed. */
+ return DRFLAC_FALSE;
+ }
+
+ DRFLAC_ASSERT(bytesRead < DRFLAC_CACHE_L1_SIZE_BYTES(bs));
+ bs->consumedBits = (drflac_uint32)(DRFLAC_CACHE_L1_SIZE_BYTES(bs) - bytesRead) * 8;
+
+ bs->cache = drflac__be2host__cache_line(bs->unalignedCache);
+ bs->cache &= DRFLAC_CACHE_L1_SELECTION_MASK(DRFLAC_CACHE_L1_BITS_REMAINING(bs)); /* <-- Make sure the consumed bits are always set to zero. Other parts of the library depend on this property. */
+ bs->unalignedByteCount = 0; /* <-- At this point the unaligned bytes have been moved into the cache and we thus have no more unaligned bytes. */
+
+#ifndef DR_FLAC_NO_CRC
+ bs->crc16Cache = bs->cache >> bs->consumedBits;
+ bs->crc16CacheIgnoredBytes = bs->consumedBits >> 3;
+#endif
+ return DRFLAC_TRUE;
+}
+
+static void drflac__reset_cache(drflac_bs* bs)
+{
+ bs->nextL2Line = DRFLAC_CACHE_L2_LINE_COUNT(bs); /* <-- This clears the L2 cache. */
+ bs->consumedBits = DRFLAC_CACHE_L1_SIZE_BITS(bs); /* <-- This clears the L1 cache. */
+ bs->cache = 0;
+ bs->unalignedByteCount = 0; /* <-- This clears the trailing unaligned bytes. */
+ bs->unalignedCache = 0;
+
+#ifndef DR_FLAC_NO_CRC
+ bs->crc16Cache = 0;
+ bs->crc16CacheIgnoredBytes = 0;
+#endif
+}
+
+
+static DRFLAC_INLINE drflac_bool32 drflac__read_uint32(drflac_bs* bs, unsigned int bitCount, drflac_uint32* pResultOut)
+{
+ DRFLAC_ASSERT(bs != NULL);
+ DRFLAC_ASSERT(pResultOut != NULL);
+ DRFLAC_ASSERT(bitCount > 0);
+ DRFLAC_ASSERT(bitCount <= 32);
+
+ if (bs->consumedBits == DRFLAC_CACHE_L1_SIZE_BITS(bs)) {
+ if (!drflac__reload_cache(bs)) {
+ return DRFLAC_FALSE;
+ }
+ }
+
+ if (bitCount <= DRFLAC_CACHE_L1_BITS_REMAINING(bs)) {
+ /*
+ If we want to load all 32-bits from a 32-bit cache we need to do it slightly differently because we can't do
+ a 32-bit shift on a 32-bit integer. This will never be the case on 64-bit caches, so we can have a slightly
+ more optimal solution for this.
+ */
+#ifdef DRFLAC_64BIT
+ *pResultOut = (drflac_uint32)DRFLAC_CACHE_L1_SELECT_AND_SHIFT(bs, bitCount);
+ bs->consumedBits += bitCount;
+ bs->cache <<= bitCount;
+#else
+ if (bitCount < DRFLAC_CACHE_L1_SIZE_BITS(bs)) {
+ *pResultOut = (drflac_uint32)DRFLAC_CACHE_L1_SELECT_AND_SHIFT(bs, bitCount);
+ bs->consumedBits += bitCount;
+ bs->cache <<= bitCount;
+ } else {
+ /* Cannot shift by 32-bits, so need to do it differently. */
+ *pResultOut = (drflac_uint32)bs->cache;
+ bs->consumedBits = DRFLAC_CACHE_L1_SIZE_BITS(bs);
+ bs->cache = 0;
+ }
+#endif
+
+ return DRFLAC_TRUE;
+ } else {
+ /* It straddles the cached data. It will never cover more than the next chunk. We just read the number in two parts and combine them. */
+ drflac_uint32 bitCountHi = DRFLAC_CACHE_L1_BITS_REMAINING(bs);
+ drflac_uint32 bitCountLo = bitCount - bitCountHi;
+ drflac_uint32 resultHi;
+
+ DRFLAC_ASSERT(bitCountHi > 0);
+ DRFLAC_ASSERT(bitCountHi < 32);
+ resultHi = (drflac_uint32)DRFLAC_CACHE_L1_SELECT_AND_SHIFT(bs, bitCountHi);
+
+ if (!drflac__reload_cache(bs)) {
+ return DRFLAC_FALSE;
+ }
+ if (bitCountLo > DRFLAC_CACHE_L1_BITS_REMAINING(bs)) {
+ /* This happens when we get to end of stream */
+ return DRFLAC_FALSE;
+ }
+
+ *pResultOut = (resultHi << bitCountLo) | (drflac_uint32)DRFLAC_CACHE_L1_SELECT_AND_SHIFT(bs, bitCountLo);
+ bs->consumedBits += bitCountLo;
+ bs->cache <<= bitCountLo;
+ return DRFLAC_TRUE;
+ }
+}
+
+static drflac_bool32 drflac__read_int32(drflac_bs* bs, unsigned int bitCount, drflac_int32* pResult)
+{
+ drflac_uint32 result;
+
+ DRFLAC_ASSERT(bs != NULL);
+ DRFLAC_ASSERT(pResult != NULL);
+ DRFLAC_ASSERT(bitCount > 0);
+ DRFLAC_ASSERT(bitCount <= 32);
+
+ if (!drflac__read_uint32(bs, bitCount, &result)) {
+ return DRFLAC_FALSE;
+ }
+
+ /* Do not attempt to shift by 32 as it's undefined. */
+ if (bitCount < 32) {
+ drflac_uint32 signbit;
+ signbit = ((result >> (bitCount-1)) & 0x01);
+ result |= (~signbit + 1) << bitCount;
+ }
+
+ *pResult = (drflac_int32)result;
+ return DRFLAC_TRUE;
+}
+
+#ifdef DRFLAC_64BIT
+static drflac_bool32 drflac__read_uint64(drflac_bs* bs, unsigned int bitCount, drflac_uint64* pResultOut)
+{
+ drflac_uint32 resultHi;
+ drflac_uint32 resultLo;
+
+ DRFLAC_ASSERT(bitCount <= 64);
+ DRFLAC_ASSERT(bitCount > 32);
+
+ if (!drflac__read_uint32(bs, bitCount - 32, &resultHi)) {
+ return DRFLAC_FALSE;
+ }
+
+ if (!drflac__read_uint32(bs, 32, &resultLo)) {
+ return DRFLAC_FALSE;
+ }
+
+ *pResultOut = (((drflac_uint64)resultHi) << 32) | ((drflac_uint64)resultLo);
+ return DRFLAC_TRUE;
+}
+#endif
+
+/* Function below is unused, but leaving it here in case I need to quickly add it again. */
+#if 0
+static drflac_bool32 drflac__read_int64(drflac_bs* bs, unsigned int bitCount, drflac_int64* pResultOut)
+{
+ drflac_uint64 result;
+ drflac_uint64 signbit;
+
+ DRFLAC_ASSERT(bitCount <= 64);
+
+ if (!drflac__read_uint64(bs, bitCount, &result)) {
+ return DRFLAC_FALSE;
+ }
+
+ signbit = ((result >> (bitCount-1)) & 0x01);
+ result |= (~signbit + 1) << bitCount;
+
+ *pResultOut = (drflac_int64)result;
+ return DRFLAC_TRUE;
+}
+#endif
+
+static drflac_bool32 drflac__read_uint16(drflac_bs* bs, unsigned int bitCount, drflac_uint16* pResult)
+{
+ drflac_uint32 result;
+
+ DRFLAC_ASSERT(bs != NULL);
+ DRFLAC_ASSERT(pResult != NULL);
+ DRFLAC_ASSERT(bitCount > 0);
+ DRFLAC_ASSERT(bitCount <= 16);
+
+ if (!drflac__read_uint32(bs, bitCount, &result)) {
+ return DRFLAC_FALSE;
+ }
+
+ *pResult = (drflac_uint16)result;
+ return DRFLAC_TRUE;
+}
+
+#if 0
+static drflac_bool32 drflac__read_int16(drflac_bs* bs, unsigned int bitCount, drflac_int16* pResult)
+{
+ drflac_int32 result;
+
+ DRFLAC_ASSERT(bs != NULL);
+ DRFLAC_ASSERT(pResult != NULL);
+ DRFLAC_ASSERT(bitCount > 0);
+ DRFLAC_ASSERT(bitCount <= 16);
+
+ if (!drflac__read_int32(bs, bitCount, &result)) {
+ return DRFLAC_FALSE;
+ }
+
+ *pResult = (drflac_int16)result;
+ return DRFLAC_TRUE;
+}
+#endif
+
+static drflac_bool32 drflac__read_uint8(drflac_bs* bs, unsigned int bitCount, drflac_uint8* pResult)
+{
+ drflac_uint32 result;
+
+ DRFLAC_ASSERT(bs != NULL);
+ DRFLAC_ASSERT(pResult != NULL);
+ DRFLAC_ASSERT(bitCount > 0);
+ DRFLAC_ASSERT(bitCount <= 8);
+
+ if (!drflac__read_uint32(bs, bitCount, &result)) {
+ return DRFLAC_FALSE;
+ }
+
+ *pResult = (drflac_uint8)result;
+ return DRFLAC_TRUE;
+}
+
+static drflac_bool32 drflac__read_int8(drflac_bs* bs, unsigned int bitCount, drflac_int8* pResult)
+{
+ drflac_int32 result;
+
+ DRFLAC_ASSERT(bs != NULL);
+ DRFLAC_ASSERT(pResult != NULL);
+ DRFLAC_ASSERT(bitCount > 0);
+ DRFLAC_ASSERT(bitCount <= 8);
+
+ if (!drflac__read_int32(bs, bitCount, &result)) {
+ return DRFLAC_FALSE;
+ }
+
+ *pResult = (drflac_int8)result;
+ return DRFLAC_TRUE;
+}
+
+
+static drflac_bool32 drflac__seek_bits(drflac_bs* bs, size_t bitsToSeek)
+{
+ if (bitsToSeek <= DRFLAC_CACHE_L1_BITS_REMAINING(bs)) {
+ bs->consumedBits += (drflac_uint32)bitsToSeek;
+ bs->cache <<= bitsToSeek;
+ return DRFLAC_TRUE;
+ } else {
+ /* It straddles the cached data. This function isn't called too frequently so I'm favouring simplicity here. */
+ bitsToSeek -= DRFLAC_CACHE_L1_BITS_REMAINING(bs);
+ bs->consumedBits += DRFLAC_CACHE_L1_BITS_REMAINING(bs);
+ bs->cache = 0;
+
+ /* Simple case. Seek in groups of the same number as bits that fit within a cache line. */
+#ifdef DRFLAC_64BIT
+ while (bitsToSeek >= DRFLAC_CACHE_L1_SIZE_BITS(bs)) {
+ drflac_uint64 bin;
+ if (!drflac__read_uint64(bs, DRFLAC_CACHE_L1_SIZE_BITS(bs), &bin)) {
+ return DRFLAC_FALSE;
+ }
+ bitsToSeek -= DRFLAC_CACHE_L1_SIZE_BITS(bs);
+ }
+#else
+ while (bitsToSeek >= DRFLAC_CACHE_L1_SIZE_BITS(bs)) {
+ drflac_uint32 bin;
+ if (!drflac__read_uint32(bs, DRFLAC_CACHE_L1_SIZE_BITS(bs), &bin)) {
+ return DRFLAC_FALSE;
+ }
+ bitsToSeek -= DRFLAC_CACHE_L1_SIZE_BITS(bs);
+ }
+#endif
+
+ /* Whole leftover bytes. */
+ while (bitsToSeek >= 8) {
+ drflac_uint8 bin;
+ if (!drflac__read_uint8(bs, 8, &bin)) {
+ return DRFLAC_FALSE;
+ }
+ bitsToSeek -= 8;
+ }
+
+ /* Leftover bits. */
+ if (bitsToSeek > 0) {
+ drflac_uint8 bin;
+ if (!drflac__read_uint8(bs, (drflac_uint32)bitsToSeek, &bin)) {
+ return DRFLAC_FALSE;
+ }
+ bitsToSeek = 0; /* <-- Necessary for the assert below. */
+ }
+
+ DRFLAC_ASSERT(bitsToSeek == 0);
+ return DRFLAC_TRUE;
+ }
+}
+
+
+/* This function moves the bit streamer to the first bit after the sync code (bit 15 of the of the frame header). It will also update the CRC-16. */
+static drflac_bool32 drflac__find_and_seek_to_next_sync_code(drflac_bs* bs)
+{
+ DRFLAC_ASSERT(bs != NULL);
+
+ /*
+ The sync code is always aligned to 8 bits. This is convenient for us because it means we can do byte-aligned movements. The first
+ thing to do is align to the next byte.
+ */
+ if (!drflac__seek_bits(bs, DRFLAC_CACHE_L1_BITS_REMAINING(bs) & 7)) {
+ return DRFLAC_FALSE;
+ }
+
+ for (;;) {
+ drflac_uint8 hi;
+
+#ifndef DR_FLAC_NO_CRC
+ drflac__reset_crc16(bs);
+#endif
+
+ if (!drflac__read_uint8(bs, 8, &hi)) {
+ return DRFLAC_FALSE;
+ }
+
+ if (hi == 0xFF) {
+ drflac_uint8 lo;
+ if (!drflac__read_uint8(bs, 6, &lo)) {
+ return DRFLAC_FALSE;
+ }
+
+ if (lo == 0x3E) {
+ return DRFLAC_TRUE;
+ } else {
+ if (!drflac__seek_bits(bs, DRFLAC_CACHE_L1_BITS_REMAINING(bs) & 7)) {
+ return DRFLAC_FALSE;
+ }
+ }
+ }
+ }
+
+ /* Should never get here. */
+ /*return DRFLAC_FALSE;*/
+}
+
+
+#if defined(DRFLAC_HAS_LZCNT_INTRINSIC)
+#define DRFLAC_IMPLEMENT_CLZ_LZCNT
+#endif
+#if defined(_MSC_VER) && _MSC_VER >= 1400 && (defined(DRFLAC_X64) || defined(DRFLAC_X86)) && !defined(__clang__)
+#define DRFLAC_IMPLEMENT_CLZ_MSVC
+#endif
+#if defined(__WATCOMC__) && defined(__386__)
+#define DRFLAC_IMPLEMENT_CLZ_WATCOM
+#endif
+#ifdef __MRC__
+#include <intrinsics.h>
+#define DRFLAC_IMPLEMENT_CLZ_MRC
+#endif
+
+static DRFLAC_INLINE drflac_uint32 drflac__clz_software(drflac_cache_t x)
+{
+ drflac_uint32 n;
+ static drflac_uint32 clz_table_4[] = {
+ 0,
+ 4,
+ 3, 3,
+ 2, 2, 2, 2,
+ 1, 1, 1, 1, 1, 1, 1, 1
+ };
+
+ if (x == 0) {
+ return sizeof(x)*8;
+ }
+
+ n = clz_table_4[x >> (sizeof(x)*8 - 4)];
+ if (n == 0) {
+#ifdef DRFLAC_64BIT
+ if ((x & ((drflac_uint64)0xFFFFFFFF << 32)) == 0) { n = 32; x <<= 32; }
+ if ((x & ((drflac_uint64)0xFFFF0000 << 32)) == 0) { n += 16; x <<= 16; }
+ if ((x & ((drflac_uint64)0xFF000000 << 32)) == 0) { n += 8; x <<= 8; }
+ if ((x & ((drflac_uint64)0xF0000000 << 32)) == 0) { n += 4; x <<= 4; }
+#else
+ if ((x & 0xFFFF0000) == 0) { n = 16; x <<= 16; }
+ if ((x & 0xFF000000) == 0) { n += 8; x <<= 8; }
+ if ((x & 0xF0000000) == 0) { n += 4; x <<= 4; }
+#endif
+ n += clz_table_4[x >> (sizeof(x)*8 - 4)];
+ }
+
+ return n - 1;
+}
+
+#ifdef DRFLAC_IMPLEMENT_CLZ_LZCNT
+static DRFLAC_INLINE drflac_bool32 drflac__is_lzcnt_supported(void)
+{
+ /* Fast compile time check for ARM. */
+#if defined(DRFLAC_HAS_LZCNT_INTRINSIC) && defined(DRFLAC_ARM) && (defined(__ARM_ARCH) && __ARM_ARCH >= 5)
+ return DRFLAC_TRUE;
+#elif defined(__MRC__)
+ return DRFLAC_TRUE;
+#else
+ /* If the compiler itself does not support the intrinsic then we'll need to return false. */
+ #ifdef DRFLAC_HAS_LZCNT_INTRINSIC
+ return drflac__gIsLZCNTSupported;
+ #else
+ return DRFLAC_FALSE;
+ #endif
+#endif
+}
+
+static DRFLAC_INLINE drflac_uint32 drflac__clz_lzcnt(drflac_cache_t x)
+{
+ /*
+ It's critical for competitive decoding performance that this function be highly optimal. With MSVC we can use the __lzcnt64() and __lzcnt() intrinsics
+ to achieve good performance, however on GCC and Clang it's a little bit more annoying. The __builtin_clzl() and __builtin_clzll() intrinsics leave
+ it undefined as to the return value when `x` is 0. We need this to be well defined as returning 32 or 64, depending on whether or not it's a 32- or
+ 64-bit build. To work around this we would need to add a conditional to check for the x = 0 case, but this creates unnecessary inefficiency. To work
+ around this problem I have written some inline assembly to emit the LZCNT (x86) or CLZ (ARM) instruction directly which removes the need to include
+ the conditional. This has worked well in the past, but for some reason Clang's MSVC compatible driver, clang-cl, does not seem to be handling this
+ in the same way as the normal Clang driver. It seems that `clang-cl` is just outputting the wrong results sometimes, maybe due to some register
+ getting clobbered?
+
+ I'm not sure if this is a bug with dr_flac's inlined assembly (most likely), a bug in `clang-cl` or just a misunderstanding on my part with inline
+ assembly rules for `clang-cl`. If somebody can identify an error in dr_flac's inlined assembly I'm happy to get that fixed.
+
+ Fortunately there is an easy workaround for this. Clang implements MSVC-specific intrinsics for compatibility. It also defines _MSC_VER for extra
+ compatibility. We can therefore just check for _MSC_VER and use the MSVC intrinsic which, fortunately for us, Clang supports. It would still be nice
+ to know how to fix the inlined assembly for correctness sake, however.
+ */
+
+#if defined(_MSC_VER) /*&& !defined(__clang__)*/ /* <-- Intentionally wanting Clang to use the MSVC __lzcnt64/__lzcnt intrinsics due to above ^. */
+ #ifdef DRFLAC_64BIT
+ return (drflac_uint32)__lzcnt64(x);
+ #else
+ return (drflac_uint32)__lzcnt(x);
+ #endif
+#else
+ #if defined(__GNUC__) || defined(__clang__)
+ #if defined(DRFLAC_X64)
+ {
+ drflac_uint64 r;
+ __asm__ __volatile__ (
+ "lzcnt{ %1, %0| %0, %1}" : "=r"(r) : "r"(x) : "cc"
+ );
+
+ return (drflac_uint32)r;
+ }
+ #elif defined(DRFLAC_X86)
+ {
+ drflac_uint32 r;
+ __asm__ __volatile__ (
+ "lzcnt{l %1, %0| %0, %1}" : "=r"(r) : "r"(x) : "cc"
+ );
+
+ return r;
+ }
+ #elif defined(DRFLAC_ARM) && (defined(__ARM_ARCH) && __ARM_ARCH >= 5) && !defined(__ARM_ARCH_6M__) && !defined(DRFLAC_64BIT) /* <-- I haven't tested 64-bit inline assembly, so only enabling this for the 32-bit build for now. */
+ {
+ unsigned int r;
+ __asm__ __volatile__ (
+ #if defined(DRFLAC_64BIT)
+ "clz %w[out], %w[in]" : [out]"=r"(r) : [in]"r"(x) /* <-- This is untested. If someone in the community could test this, that would be appreciated! */
+ #else
+ "clz %[out], %[in]" : [out]"=r"(r) : [in]"r"(x)
+ #endif
+ );
+
+ return r;
+ }
+ #else
+ if (x == 0) {
+ return sizeof(x)*8;
+ }
+ #ifdef DRFLAC_64BIT
+ return (drflac_uint32)__builtin_clzll((drflac_uint64)x);
+ #else
+ return (drflac_uint32)__builtin_clzl((drflac_uint32)x);
+ #endif
+ #endif
+ #else
+ /* Unsupported compiler. */
+ #error "This compiler does not support the lzcnt intrinsic."
+ #endif
+#endif
+}
+#endif
+
+#ifdef DRFLAC_IMPLEMENT_CLZ_MSVC
+#include <intrin.h> /* For BitScanReverse(). */
+
+static DRFLAC_INLINE drflac_uint32 drflac__clz_msvc(drflac_cache_t x)
+{
+ drflac_uint32 n;
+
+ if (x == 0) {
+ return sizeof(x)*8;
+ }
+
+#ifdef DRFLAC_64BIT
+ _BitScanReverse64((unsigned long*)&n, x);
+#else
+ _BitScanReverse((unsigned long*)&n, x);
+#endif
+ return sizeof(x)*8 - n - 1;
+}
+#endif
+
+#ifdef DRFLAC_IMPLEMENT_CLZ_WATCOM
+static __inline drflac_uint32 drflac__clz_watcom (drflac_uint32);
+#ifdef DRFLAC_IMPLEMENT_CLZ_WATCOM_LZCNT
+/* Use the LZCNT instruction (only available on some processors since the 2010s). */
+#pragma aux drflac__clz_watcom_lzcnt = \
+ "db 0F3h, 0Fh, 0BDh, 0C0h" /* lzcnt eax, eax */ \
+ parm [eax] \
+ value [eax] \
+ modify nomemory;
+#else
+/* Use the 386+-compatible implementation. */
+#pragma aux drflac__clz_watcom = \
+ "bsr eax, eax" \
+ "xor eax, 31" \
+ parm [eax] nomemory \
+ value [eax] \
+ modify exact [eax] nomemory;
+#endif
+#endif
+
+static DRFLAC_INLINE drflac_uint32 drflac__clz(drflac_cache_t x)
+{
+#ifdef DRFLAC_IMPLEMENT_CLZ_LZCNT
+ if (drflac__is_lzcnt_supported()) {
+ return drflac__clz_lzcnt(x);
+ } else
+#endif
+ {
+#ifdef DRFLAC_IMPLEMENT_CLZ_MSVC
+ return drflac__clz_msvc(x);
+#elif defined(DRFLAC_IMPLEMENT_CLZ_WATCOM_LZCNT)
+ return drflac__clz_watcom_lzcnt(x);
+#elif defined(DRFLAC_IMPLEMENT_CLZ_WATCOM)
+ return (x == 0) ? sizeof(x)*8 : drflac__clz_watcom(x);
+#elif defined(__MRC__)
+ return __cntlzw(x);
+#else
+ return drflac__clz_software(x);
+#endif
+ }
+}
+
+
+static DRFLAC_INLINE drflac_bool32 drflac__seek_past_next_set_bit(drflac_bs* bs, unsigned int* pOffsetOut)
+{
+ drflac_uint32 zeroCounter = 0;
+ drflac_uint32 setBitOffsetPlus1;
+
+ while (bs->cache == 0) {
+ zeroCounter += (drflac_uint32)DRFLAC_CACHE_L1_BITS_REMAINING(bs);
+ if (!drflac__reload_cache(bs)) {
+ return DRFLAC_FALSE;
+ }
+ }
+
+ if (bs->cache == 1) {
+ /* Not catching this would lead to undefined behaviour: a shift of a 32-bit number by 32 or more is undefined */
+ *pOffsetOut = zeroCounter + (drflac_uint32)DRFLAC_CACHE_L1_BITS_REMAINING(bs) - 1;
+ if (!drflac__reload_cache(bs)) {
+ return DRFLAC_FALSE;
+ }
+
+ return DRFLAC_TRUE;
+ }
+
+ setBitOffsetPlus1 = drflac__clz(bs->cache);
+ setBitOffsetPlus1 += 1;
+
+ if (setBitOffsetPlus1 > DRFLAC_CACHE_L1_BITS_REMAINING(bs)) {
+ /* This happens when we get to end of stream */
+ return DRFLAC_FALSE;
+ }
+
+ bs->consumedBits += setBitOffsetPlus1;
+ bs->cache <<= setBitOffsetPlus1;
+
+ *pOffsetOut = zeroCounter + setBitOffsetPlus1 - 1;
+ return DRFLAC_TRUE;
+}
+
+
+
+static drflac_bool32 drflac__seek_to_byte(drflac_bs* bs, drflac_uint64 offsetFromStart)
+{
+ DRFLAC_ASSERT(bs != NULL);
+ DRFLAC_ASSERT(offsetFromStart > 0);
+
+ /*
+ Seeking from the start is not quite as trivial as it sounds because the onSeek callback takes a signed 32-bit integer (which
+ is intentional because it simplifies the implementation of the onSeek callbacks), however offsetFromStart is unsigned 64-bit.
+ To resolve we just need to do an initial seek from the start, and then a series of offset seeks to make up the remainder.
+ */
+ if (offsetFromStart > 0x7FFFFFFF) {
+ drflac_uint64 bytesRemaining = offsetFromStart;
+ if (!bs->onSeek(bs->pUserData, 0x7FFFFFFF, drflac_seek_origin_start)) {
+ return DRFLAC_FALSE;
+ }
+ bytesRemaining -= 0x7FFFFFFF;
+
+ while (bytesRemaining > 0x7FFFFFFF) {
+ if (!bs->onSeek(bs->pUserData, 0x7FFFFFFF, drflac_seek_origin_current)) {
+ return DRFLAC_FALSE;
+ }
+ bytesRemaining -= 0x7FFFFFFF;
+ }
+
+ if (bytesRemaining > 0) {
+ if (!bs->onSeek(bs->pUserData, (int)bytesRemaining, drflac_seek_origin_current)) {
+ return DRFLAC_FALSE;
+ }
+ }
+ } else {
+ if (!bs->onSeek(bs->pUserData, (int)offsetFromStart, drflac_seek_origin_start)) {
+ return DRFLAC_FALSE;
+ }
+ }
+
+ /* The cache should be reset to force a reload of fresh data from the client. */
+ drflac__reset_cache(bs);
+ return DRFLAC_TRUE;
+}
+
+
+static drflac_result drflac__read_utf8_coded_number(drflac_bs* bs, drflac_uint64* pNumberOut, drflac_uint8* pCRCOut)
+{
+ drflac_uint8 crc;
+ drflac_uint64 result;
+ drflac_uint8 utf8[7] = {0};
+ int byteCount;
+ int i;
+
+ DRFLAC_ASSERT(bs != NULL);
+ DRFLAC_ASSERT(pNumberOut != NULL);
+ DRFLAC_ASSERT(pCRCOut != NULL);
+
+ crc = *pCRCOut;
+
+ if (!drflac__read_uint8(bs, 8, utf8)) {
+ *pNumberOut = 0;
+ return DRFLAC_AT_END;
+ }
+ crc = drflac_crc8(crc, utf8[0], 8);
+
+ if ((utf8[0] & 0x80) == 0) {
+ *pNumberOut = utf8[0];
+ *pCRCOut = crc;
+ return DRFLAC_SUCCESS;
+ }
+
+ /*byteCount = 1;*/
+ if ((utf8[0] & 0xE0) == 0xC0) {
+ byteCount = 2;
+ } else if ((utf8[0] & 0xF0) == 0xE0) {
+ byteCount = 3;
+ } else if ((utf8[0] & 0xF8) == 0xF0) {
+ byteCount = 4;
+ } else if ((utf8[0] & 0xFC) == 0xF8) {
+ byteCount = 5;
+ } else if ((utf8[0] & 0xFE) == 0xFC) {
+ byteCount = 6;
+ } else if ((utf8[0] & 0xFF) == 0xFE) {
+ byteCount = 7;
+ } else {
+ *pNumberOut = 0;
+ return DRFLAC_CRC_MISMATCH; /* Bad UTF-8 encoding. */
+ }
+
+ /* Read extra bytes. */
+ DRFLAC_ASSERT(byteCount > 1);
+
+ result = (drflac_uint64)(utf8[0] & (0xFF >> (byteCount + 1)));
+ for (i = 1; i < byteCount; ++i) {
+ if (!drflac__read_uint8(bs, 8, utf8 + i)) {
+ *pNumberOut = 0;
+ return DRFLAC_AT_END;
+ }
+ crc = drflac_crc8(crc, utf8[i], 8);
+
+ result = (result << 6) | (utf8[i] & 0x3F);
+ }
+
+ *pNumberOut = result;
+ *pCRCOut = crc;
+ return DRFLAC_SUCCESS;
+}
+
+
+static DRFLAC_INLINE drflac_uint32 drflac__ilog2_u32(drflac_uint32 x)
+{
+#if 1 /* Needs optimizing. */
+ drflac_uint32 result = 0;
+ while (x > 0) {
+ result += 1;
+ x >>= 1;
+ }
+
+ return result;
+#endif
+}
+
+static DRFLAC_INLINE drflac_bool32 drflac__use_64_bit_prediction(drflac_uint32 bitsPerSample, drflac_uint32 order, drflac_uint32 precision)
+{
+ /* https://web.archive.org/web/20220205005724/https://github.com/ietf-wg-cellar/flac-specification/blob/37a49aa48ba4ba12e8757badfc59c0df35435fec/rfc_backmatter.md */
+ return bitsPerSample + precision + drflac__ilog2_u32(order) > 32;
+}
+
+
+/*
+The next two functions are responsible for calculating the prediction.
+
+When the bits per sample is >16 we need to use 64-bit integer arithmetic because otherwise we'll run out of precision. It's
+safe to assume this will be slower on 32-bit platforms so we use a more optimal solution when the bits per sample is <=16.
+*/
+#if defined(__clang__)
+__attribute__((no_sanitize("signed-integer-overflow")))
+#endif
+static DRFLAC_INLINE drflac_int32 drflac__calculate_prediction_32(drflac_uint32 order, drflac_int32 shift, const drflac_int32* coefficients, drflac_int32* pDecodedSamples)
+{
+ drflac_int32 prediction = 0;
+
+ DRFLAC_ASSERT(order <= 32);
+
+ /* 32-bit version. */
+
+ /* VC++ optimizes this to a single jmp. I've not yet verified this for other compilers. */
+ switch (order)
+ {
+ case 32: prediction += coefficients[31] * pDecodedSamples[-32];
+ case 31: prediction += coefficients[30] * pDecodedSamples[-31];
+ case 30: prediction += coefficients[29] * pDecodedSamples[-30];
+ case 29: prediction += coefficients[28] * pDecodedSamples[-29];
+ case 28: prediction += coefficients[27] * pDecodedSamples[-28];
+ case 27: prediction += coefficients[26] * pDecodedSamples[-27];
+ case 26: prediction += coefficients[25] * pDecodedSamples[-26];
+ case 25: prediction += coefficients[24] * pDecodedSamples[-25];
+ case 24: prediction += coefficients[23] * pDecodedSamples[-24];
+ case 23: prediction += coefficients[22] * pDecodedSamples[-23];
+ case 22: prediction += coefficients[21] * pDecodedSamples[-22];
+ case 21: prediction += coefficients[20] * pDecodedSamples[-21];
+ case 20: prediction += coefficients[19] * pDecodedSamples[-20];
+ case 19: prediction += coefficients[18] * pDecodedSamples[-19];
+ case 18: prediction += coefficients[17] * pDecodedSamples[-18];
+ case 17: prediction += coefficients[16] * pDecodedSamples[-17];
+ case 16: prediction += coefficients[15] * pDecodedSamples[-16];
+ case 15: prediction += coefficients[14] * pDecodedSamples[-15];
+ case 14: prediction += coefficients[13] * pDecodedSamples[-14];
+ case 13: prediction += coefficients[12] * pDecodedSamples[-13];
+ case 12: prediction += coefficients[11] * pDecodedSamples[-12];
+ case 11: prediction += coefficients[10] * pDecodedSamples[-11];
+ case 10: prediction += coefficients[ 9] * pDecodedSamples[-10];
+ case 9: prediction += coefficients[ 8] * pDecodedSamples[- 9];
+ case 8: prediction += coefficients[ 7] * pDecodedSamples[- 8];
+ case 7: prediction += coefficients[ 6] * pDecodedSamples[- 7];
+ case 6: prediction += coefficients[ 5] * pDecodedSamples[- 6];
+ case 5: prediction += coefficients[ 4] * pDecodedSamples[- 5];
+ case 4: prediction += coefficients[ 3] * pDecodedSamples[- 4];
+ case 3: prediction += coefficients[ 2] * pDecodedSamples[- 3];
+ case 2: prediction += coefficients[ 1] * pDecodedSamples[- 2];
+ case 1: prediction += coefficients[ 0] * pDecodedSamples[- 1];
+ }
+
+ return (drflac_int32)(prediction >> shift);
+}
+
+static DRFLAC_INLINE drflac_int32 drflac__calculate_prediction_64(drflac_uint32 order, drflac_int32 shift, const drflac_int32* coefficients, drflac_int32* pDecodedSamples)
+{
+ drflac_int64 prediction;
+
+ DRFLAC_ASSERT(order <= 32);
+
+ /* 64-bit version. */
+
+ /* This method is faster on the 32-bit build when compiling with VC++. See note below. */
+#ifndef DRFLAC_64BIT
+ if (order == 8)
+ {
+ prediction = coefficients[0] * (drflac_int64)pDecodedSamples[-1];
+ prediction += coefficients[1] * (drflac_int64)pDecodedSamples[-2];
+ prediction += coefficients[2] * (drflac_int64)pDecodedSamples[-3];
+ prediction += coefficients[3] * (drflac_int64)pDecodedSamples[-4];
+ prediction += coefficients[4] * (drflac_int64)pDecodedSamples[-5];
+ prediction += coefficients[5] * (drflac_int64)pDecodedSamples[-6];
+ prediction += coefficients[6] * (drflac_int64)pDecodedSamples[-7];
+ prediction += coefficients[7] * (drflac_int64)pDecodedSamples[-8];
+ }
+ else if (order == 7)
+ {
+ prediction = coefficients[0] * (drflac_int64)pDecodedSamples[-1];
+ prediction += coefficients[1] * (drflac_int64)pDecodedSamples[-2];
+ prediction += coefficients[2] * (drflac_int64)pDecodedSamples[-3];
+ prediction += coefficients[3] * (drflac_int64)pDecodedSamples[-4];
+ prediction += coefficients[4] * (drflac_int64)pDecodedSamples[-5];
+ prediction += coefficients[5] * (drflac_int64)pDecodedSamples[-6];
+ prediction += coefficients[6] * (drflac_int64)pDecodedSamples[-7];
+ }
+ else if (order == 3)
+ {
+ prediction = coefficients[0] * (drflac_int64)pDecodedSamples[-1];
+ prediction += coefficients[1] * (drflac_int64)pDecodedSamples[-2];
+ prediction += coefficients[2] * (drflac_int64)pDecodedSamples[-3];
+ }
+ else if (order == 6)
+ {
+ prediction = coefficients[0] * (drflac_int64)pDecodedSamples[-1];
+ prediction += coefficients[1] * (drflac_int64)pDecodedSamples[-2];
+ prediction += coefficients[2] * (drflac_int64)pDecodedSamples[-3];
+ prediction += coefficients[3] * (drflac_int64)pDecodedSamples[-4];
+ prediction += coefficients[4] * (drflac_int64)pDecodedSamples[-5];
+ prediction += coefficients[5] * (drflac_int64)pDecodedSamples[-6];
+ }
+ else if (order == 5)
+ {
+ prediction = coefficients[0] * (drflac_int64)pDecodedSamples[-1];
+ prediction += coefficients[1] * (drflac_int64)pDecodedSamples[-2];
+ prediction += coefficients[2] * (drflac_int64)pDecodedSamples[-3];
+ prediction += coefficients[3] * (drflac_int64)pDecodedSamples[-4];
+ prediction += coefficients[4] * (drflac_int64)pDecodedSamples[-5];
+ }
+ else if (order == 4)
+ {
+ prediction = coefficients[0] * (drflac_int64)pDecodedSamples[-1];
+ prediction += coefficients[1] * (drflac_int64)pDecodedSamples[-2];
+ prediction += coefficients[2] * (drflac_int64)pDecodedSamples[-3];
+ prediction += coefficients[3] * (drflac_int64)pDecodedSamples[-4];
+ }
+ else if (order == 12)
+ {
+ prediction = coefficients[0] * (drflac_int64)pDecodedSamples[-1];
+ prediction += coefficients[1] * (drflac_int64)pDecodedSamples[-2];
+ prediction += coefficients[2] * (drflac_int64)pDecodedSamples[-3];
+ prediction += coefficients[3] * (drflac_int64)pDecodedSamples[-4];
+ prediction += coefficients[4] * (drflac_int64)pDecodedSamples[-5];
+ prediction += coefficients[5] * (drflac_int64)pDecodedSamples[-6];
+ prediction += coefficients[6] * (drflac_int64)pDecodedSamples[-7];
+ prediction += coefficients[7] * (drflac_int64)pDecodedSamples[-8];
+ prediction += coefficients[8] * (drflac_int64)pDecodedSamples[-9];
+ prediction += coefficients[9] * (drflac_int64)pDecodedSamples[-10];
+ prediction += coefficients[10] * (drflac_int64)pDecodedSamples[-11];
+ prediction += coefficients[11] * (drflac_int64)pDecodedSamples[-12];
+ }
+ else if (order == 2)
+ {
+ prediction = coefficients[0] * (drflac_int64)pDecodedSamples[-1];
+ prediction += coefficients[1] * (drflac_int64)pDecodedSamples[-2];
+ }
+ else if (order == 1)
+ {
+ prediction = coefficients[0] * (drflac_int64)pDecodedSamples[-1];
+ }
+ else if (order == 10)
+ {
+ prediction = coefficients[0] * (drflac_int64)pDecodedSamples[-1];
+ prediction += coefficients[1] * (drflac_int64)pDecodedSamples[-2];
+ prediction += coefficients[2] * (drflac_int64)pDecodedSamples[-3];
+ prediction += coefficients[3] * (drflac_int64)pDecodedSamples[-4];
+ prediction += coefficients[4] * (drflac_int64)pDecodedSamples[-5];
+ prediction += coefficients[5] * (drflac_int64)pDecodedSamples[-6];
+ prediction += coefficients[6] * (drflac_int64)pDecodedSamples[-7];
+ prediction += coefficients[7] * (drflac_int64)pDecodedSamples[-8];
+ prediction += coefficients[8] * (drflac_int64)pDecodedSamples[-9];
+ prediction += coefficients[9] * (drflac_int64)pDecodedSamples[-10];
+ }
+ else if (order == 9)
+ {
+ prediction = coefficients[0] * (drflac_int64)pDecodedSamples[-1];
+ prediction += coefficients[1] * (drflac_int64)pDecodedSamples[-2];
+ prediction += coefficients[2] * (drflac_int64)pDecodedSamples[-3];
+ prediction += coefficients[3] * (drflac_int64)pDecodedSamples[-4];
+ prediction += coefficients[4] * (drflac_int64)pDecodedSamples[-5];
+ prediction += coefficients[5] * (drflac_int64)pDecodedSamples[-6];
+ prediction += coefficients[6] * (drflac_int64)pDecodedSamples[-7];
+ prediction += coefficients[7] * (drflac_int64)pDecodedSamples[-8];
+ prediction += coefficients[8] * (drflac_int64)pDecodedSamples[-9];
+ }
+ else if (order == 11)
+ {
+ prediction = coefficients[0] * (drflac_int64)pDecodedSamples[-1];
+ prediction += coefficients[1] * (drflac_int64)pDecodedSamples[-2];
+ prediction += coefficients[2] * (drflac_int64)pDecodedSamples[-3];
+ prediction += coefficients[3] * (drflac_int64)pDecodedSamples[-4];
+ prediction += coefficients[4] * (drflac_int64)pDecodedSamples[-5];
+ prediction += coefficients[5] * (drflac_int64)pDecodedSamples[-6];
+ prediction += coefficients[6] * (drflac_int64)pDecodedSamples[-7];
+ prediction += coefficients[7] * (drflac_int64)pDecodedSamples[-8];
+ prediction += coefficients[8] * (drflac_int64)pDecodedSamples[-9];
+ prediction += coefficients[9] * (drflac_int64)pDecodedSamples[-10];
+ prediction += coefficients[10] * (drflac_int64)pDecodedSamples[-11];
+ }
+ else
+ {
+ int j;
+
+ prediction = 0;
+ for (j = 0; j < (int)order; ++j) {
+ prediction += coefficients[j] * (drflac_int64)pDecodedSamples[-j-1];
+ }
+ }
+#endif
+
+ /*
+ VC++ optimizes this to a single jmp instruction, but only the 64-bit build. The 32-bit build generates less efficient code for some
+ reason. The ugly version above is faster so we'll just switch between the two depending on the target platform.
+ */
+#ifdef DRFLAC_64BIT
+ prediction = 0;
+ switch (order)
+ {
+ case 32: prediction += coefficients[31] * (drflac_int64)pDecodedSamples[-32];
+ case 31: prediction += coefficients[30] * (drflac_int64)pDecodedSamples[-31];
+ case 30: prediction += coefficients[29] * (drflac_int64)pDecodedSamples[-30];
+ case 29: prediction += coefficients[28] * (drflac_int64)pDecodedSamples[-29];
+ case 28: prediction += coefficients[27] * (drflac_int64)pDecodedSamples[-28];
+ case 27: prediction += coefficients[26] * (drflac_int64)pDecodedSamples[-27];
+ case 26: prediction += coefficients[25] * (drflac_int64)pDecodedSamples[-26];
+ case 25: prediction += coefficients[24] * (drflac_int64)pDecodedSamples[-25];
+ case 24: prediction += coefficients[23] * (drflac_int64)pDecodedSamples[-24];
+ case 23: prediction += coefficients[22] * (drflac_int64)pDecodedSamples[-23];
+ case 22: prediction += coefficients[21] * (drflac_int64)pDecodedSamples[-22];
+ case 21: prediction += coefficients[20] * (drflac_int64)pDecodedSamples[-21];
+ case 20: prediction += coefficients[19] * (drflac_int64)pDecodedSamples[-20];
+ case 19: prediction += coefficients[18] * (drflac_int64)pDecodedSamples[-19];
+ case 18: prediction += coefficients[17] * (drflac_int64)pDecodedSamples[-18];
+ case 17: prediction += coefficients[16] * (drflac_int64)pDecodedSamples[-17];
+ case 16: prediction += coefficients[15] * (drflac_int64)pDecodedSamples[-16];
+ case 15: prediction += coefficients[14] * (drflac_int64)pDecodedSamples[-15];
+ case 14: prediction += coefficients[13] * (drflac_int64)pDecodedSamples[-14];
+ case 13: prediction += coefficients[12] * (drflac_int64)pDecodedSamples[-13];
+ case 12: prediction += coefficients[11] * (drflac_int64)pDecodedSamples[-12];
+ case 11: prediction += coefficients[10] * (drflac_int64)pDecodedSamples[-11];
+ case 10: prediction += coefficients[ 9] * (drflac_int64)pDecodedSamples[-10];
+ case 9: prediction += coefficients[ 8] * (drflac_int64)pDecodedSamples[- 9];
+ case 8: prediction += coefficients[ 7] * (drflac_int64)pDecodedSamples[- 8];
+ case 7: prediction += coefficients[ 6] * (drflac_int64)pDecodedSamples[- 7];
+ case 6: prediction += coefficients[ 5] * (drflac_int64)pDecodedSamples[- 6];
+ case 5: prediction += coefficients[ 4] * (drflac_int64)pDecodedSamples[- 5];
+ case 4: prediction += coefficients[ 3] * (drflac_int64)pDecodedSamples[- 4];
+ case 3: prediction += coefficients[ 2] * (drflac_int64)pDecodedSamples[- 3];
+ case 2: prediction += coefficients[ 1] * (drflac_int64)pDecodedSamples[- 2];
+ case 1: prediction += coefficients[ 0] * (drflac_int64)pDecodedSamples[- 1];
+ }
+#endif
+
+ return (drflac_int32)(prediction >> shift);
+}
+
+
+#if 0
+/*
+Reference implementation for reading and decoding samples with residual. This is intentionally left unoptimized for the
+sake of readability and should only be used as a reference.
+*/
+static drflac_bool32 drflac__decode_samples_with_residual__rice__reference(drflac_bs* bs, drflac_uint32 bitsPerSample, drflac_uint32 count, drflac_uint8 riceParam, drflac_uint32 lpcOrder, drflac_int32 lpcShift, drflac_uint32 lpcPrecision, const drflac_int32* coefficients, drflac_int32* pSamplesOut)
+{
+ drflac_uint32 i;
+
+ DRFLAC_ASSERT(bs != NULL);
+ DRFLAC_ASSERT(pSamplesOut != NULL);
+
+ for (i = 0; i < count; ++i) {
+ drflac_uint32 zeroCounter = 0;
+ for (;;) {
+ drflac_uint8 bit;
+ if (!drflac__read_uint8(bs, 1, &bit)) {
+ return DRFLAC_FALSE;
+ }
+
+ if (bit == 0) {
+ zeroCounter += 1;
+ } else {
+ break;
+ }
+ }
+
+ drflac_uint32 decodedRice;
+ if (riceParam > 0) {
+ if (!drflac__read_uint32(bs, riceParam, &decodedRice)) {
+ return DRFLAC_FALSE;
+ }
+ } else {
+ decodedRice = 0;
+ }
+
+ decodedRice |= (zeroCounter << riceParam);
+ if ((decodedRice & 0x01)) {
+ decodedRice = ~(decodedRice >> 1);
+ } else {
+ decodedRice = (decodedRice >> 1);
+ }
+
+
+ if (drflac__use_64_bit_prediction(bitsPerSample, lpcOrder, lpcPrecision)) {
+ pSamplesOut[i] = decodedRice + drflac__calculate_prediction_64(lpcOrder, lpcShift, coefficients, pSamplesOut + i);
+ } else {
+ pSamplesOut[i] = decodedRice + drflac__calculate_prediction_32(lpcOrder, lpcShift, coefficients, pSamplesOut + i);
+ }
+ }
+
+ return DRFLAC_TRUE;
+}
+#endif
+
+#if 0
+static drflac_bool32 drflac__read_rice_parts__reference(drflac_bs* bs, drflac_uint8 riceParam, drflac_uint32* pZeroCounterOut, drflac_uint32* pRiceParamPartOut)
+{
+ drflac_uint32 zeroCounter = 0;
+ drflac_uint32 decodedRice;
+
+ for (;;) {
+ drflac_uint8 bit;
+ if (!drflac__read_uint8(bs, 1, &bit)) {
+ return DRFLAC_FALSE;
+ }
+
+ if (bit == 0) {
+ zeroCounter += 1;
+ } else {
+ break;
+ }
+ }
+
+ if (riceParam > 0) {
+ if (!drflac__read_uint32(bs, riceParam, &decodedRice)) {
+ return DRFLAC_FALSE;
+ }
+ } else {
+ decodedRice = 0;
+ }
+
+ *pZeroCounterOut = zeroCounter;
+ *pRiceParamPartOut = decodedRice;
+ return DRFLAC_TRUE;
+}
+#endif
+
+#if 0
+static DRFLAC_INLINE drflac_bool32 drflac__read_rice_parts(drflac_bs* bs, drflac_uint8 riceParam, drflac_uint32* pZeroCounterOut, drflac_uint32* pRiceParamPartOut)
+{
+ drflac_cache_t riceParamMask;
+ drflac_uint32 zeroCounter;
+ drflac_uint32 setBitOffsetPlus1;
+ drflac_uint32 riceParamPart;
+ drflac_uint32 riceLength;
+
+ DRFLAC_ASSERT(riceParam > 0); /* <-- riceParam should never be 0. drflac__read_rice_parts__param_equals_zero() should be used instead for this case. */
+
+ riceParamMask = DRFLAC_CACHE_L1_SELECTION_MASK(riceParam);
+
+ zeroCounter = 0;
+ while (bs->cache == 0) {
+ zeroCounter += (drflac_uint32)DRFLAC_CACHE_L1_BITS_REMAINING(bs);
+ if (!drflac__reload_cache(bs)) {
+ return DRFLAC_FALSE;
+ }
+ }
+
+ setBitOffsetPlus1 = drflac__clz(bs->cache);
+ zeroCounter += setBitOffsetPlus1;
+ setBitOffsetPlus1 += 1;
+
+ riceLength = setBitOffsetPlus1 + riceParam;
+ if (riceLength < DRFLAC_CACHE_L1_BITS_REMAINING(bs)) {
+ riceParamPart = (drflac_uint32)((bs->cache & (riceParamMask >> setBitOffsetPlus1)) >> DRFLAC_CACHE_L1_SELECTION_SHIFT(bs, riceLength));
+
+ bs->consumedBits += riceLength;
+ bs->cache <<= riceLength;
+ } else {
+ drflac_uint32 bitCountLo;
+ drflac_cache_t resultHi;
+
+ bs->consumedBits += riceLength;
+ bs->cache <<= setBitOffsetPlus1 & (DRFLAC_CACHE_L1_SIZE_BITS(bs)-1); /* <-- Equivalent to "if (setBitOffsetPlus1 < DRFLAC_CACHE_L1_SIZE_BITS(bs)) { bs->cache <<= setBitOffsetPlus1; }" */
+
+ /* It straddles the cached data. It will never cover more than the next chunk. We just read the number in two parts and combine them. */
+ bitCountLo = bs->consumedBits - DRFLAC_CACHE_L1_SIZE_BITS(bs);
+ resultHi = DRFLAC_CACHE_L1_SELECT_AND_SHIFT(bs, riceParam); /* <-- Use DRFLAC_CACHE_L1_SELECT_AND_SHIFT_SAFE() if ever this function allows riceParam=0. */
+
+ if (bs->nextL2Line < DRFLAC_CACHE_L2_LINE_COUNT(bs)) {
+#ifndef DR_FLAC_NO_CRC
+ drflac__update_crc16(bs);
+#endif
+ bs->cache = drflac__be2host__cache_line(bs->cacheL2[bs->nextL2Line++]);
+ bs->consumedBits = 0;
+#ifndef DR_FLAC_NO_CRC
+ bs->crc16Cache = bs->cache;
+#endif
+ } else {
+ /* Slow path. We need to fetch more data from the client. */
+ if (!drflac__reload_cache(bs)) {
+ return DRFLAC_FALSE;
+ }
+ if (bitCountLo > DRFLAC_CACHE_L1_BITS_REMAINING(bs)) {
+ /* This happens when we get to end of stream */
+ return DRFLAC_FALSE;
+ }
+ }
+
+ riceParamPart = (drflac_uint32)(resultHi | DRFLAC_CACHE_L1_SELECT_AND_SHIFT_SAFE(bs, bitCountLo));
+
+ bs->consumedBits += bitCountLo;
+ bs->cache <<= bitCountLo;
+ }
+
+ pZeroCounterOut[0] = zeroCounter;
+ pRiceParamPartOut[0] = riceParamPart;
+
+ return DRFLAC_TRUE;
+}
+#endif
+
+static DRFLAC_INLINE drflac_bool32 drflac__read_rice_parts_x1(drflac_bs* bs, drflac_uint8 riceParam, drflac_uint32* pZeroCounterOut, drflac_uint32* pRiceParamPartOut)
+{
+ drflac_uint32 riceParamPlus1 = riceParam + 1;
+ /*drflac_cache_t riceParamPlus1Mask = DRFLAC_CACHE_L1_SELECTION_MASK(riceParamPlus1);*/
+ drflac_uint32 riceParamPlus1Shift = DRFLAC_CACHE_L1_SELECTION_SHIFT(bs, riceParamPlus1);
+ drflac_uint32 riceParamPlus1MaxConsumedBits = DRFLAC_CACHE_L1_SIZE_BITS(bs) - riceParamPlus1;
+
+ /*
+ The idea here is to use local variables for the cache in an attempt to encourage the compiler to store them in registers. I have
+ no idea how this will work in practice...
+ */
+ drflac_cache_t bs_cache = bs->cache;
+ drflac_uint32 bs_consumedBits = bs->consumedBits;
+
+ /* The first thing to do is find the first unset bit. Most likely a bit will be set in the current cache line. */
+ drflac_uint32 lzcount = drflac__clz(bs_cache);
+ if (lzcount < sizeof(bs_cache)*8) {
+ pZeroCounterOut[0] = lzcount;
+
+ /*
+ It is most likely that the riceParam part (which comes after the zero counter) is also on this cache line. When extracting
+ this, we include the set bit from the unary coded part because it simplifies cache management. This bit will be handled
+ outside of this function at a higher level.
+ */
+ extract_rice_param_part:
+ bs_cache <<= lzcount;
+ bs_consumedBits += lzcount;
+
+ if (bs_consumedBits <= riceParamPlus1MaxConsumedBits) {
+ /* Getting here means the rice parameter part is wholly contained within the current cache line. */
+ pRiceParamPartOut[0] = (drflac_uint32)(bs_cache >> riceParamPlus1Shift);
+ bs_cache <<= riceParamPlus1;
+ bs_consumedBits += riceParamPlus1;
+ } else {
+ drflac_uint32 riceParamPartHi;
+ drflac_uint32 riceParamPartLo;
+ drflac_uint32 riceParamPartLoBitCount;
+
+ /*
+ Getting here means the rice parameter part straddles the cache line. We need to read from the tail of the current cache
+ line, reload the cache, and then combine it with the head of the next cache line.
+ */
+
+ /* Grab the high part of the rice parameter part. */
+ riceParamPartHi = (drflac_uint32)(bs_cache >> riceParamPlus1Shift);
+
+ /* Before reloading the cache we need to grab the size in bits of the low part. */
+ riceParamPartLoBitCount = bs_consumedBits - riceParamPlus1MaxConsumedBits;
+ DRFLAC_ASSERT(riceParamPartLoBitCount > 0 && riceParamPartLoBitCount < 32);
+
+ /* Now reload the cache. */
+ if (bs->nextL2Line < DRFLAC_CACHE_L2_LINE_COUNT(bs)) {
+ #ifndef DR_FLAC_NO_CRC
+ drflac__update_crc16(bs);
+ #endif
+ bs_cache = drflac__be2host__cache_line(bs->cacheL2[bs->nextL2Line++]);
+ bs_consumedBits = riceParamPartLoBitCount;
+ #ifndef DR_FLAC_NO_CRC
+ bs->crc16Cache = bs_cache;
+ #endif
+ } else {
+ /* Slow path. We need to fetch more data from the client. */
+ if (!drflac__reload_cache(bs)) {
+ return DRFLAC_FALSE;
+ }
+ if (riceParamPartLoBitCount > DRFLAC_CACHE_L1_BITS_REMAINING(bs)) {
+ /* This happens when we get to end of stream */
+ return DRFLAC_FALSE;
+ }
+
+ bs_cache = bs->cache;
+ bs_consumedBits = bs->consumedBits + riceParamPartLoBitCount;
+ }
+
+ /* We should now have enough information to construct the rice parameter part. */
+ riceParamPartLo = (drflac_uint32)(bs_cache >> (DRFLAC_CACHE_L1_SELECTION_SHIFT(bs, riceParamPartLoBitCount)));
+ pRiceParamPartOut[0] = riceParamPartHi | riceParamPartLo;
+
+ bs_cache <<= riceParamPartLoBitCount;
+ }
+ } else {
+ /*
+ Getting here means there are no bits set on the cache line. This is a less optimal case because we just wasted a call
+ to drflac__clz() and we need to reload the cache.
+ */
+ drflac_uint32 zeroCounter = (drflac_uint32)(DRFLAC_CACHE_L1_SIZE_BITS(bs) - bs_consumedBits);
+ for (;;) {
+ if (bs->nextL2Line < DRFLAC_CACHE_L2_LINE_COUNT(bs)) {
+ #ifndef DR_FLAC_NO_CRC
+ drflac__update_crc16(bs);
+ #endif
+ bs_cache = drflac__be2host__cache_line(bs->cacheL2[bs->nextL2Line++]);
+ bs_consumedBits = 0;
+ #ifndef DR_FLAC_NO_CRC
+ bs->crc16Cache = bs_cache;
+ #endif
+ } else {
+ /* Slow path. We need to fetch more data from the client. */
+ if (!drflac__reload_cache(bs)) {
+ return DRFLAC_FALSE;
+ }
+
+ bs_cache = bs->cache;
+ bs_consumedBits = bs->consumedBits;
+ }
+
+ lzcount = drflac__clz(bs_cache);
+ zeroCounter += lzcount;
+
+ if (lzcount < sizeof(bs_cache)*8) {
+ break;
+ }
+ }
+
+ pZeroCounterOut[0] = zeroCounter;
+ goto extract_rice_param_part;
+ }
+
+ /* Make sure the cache is restored at the end of it all. */
+ bs->cache = bs_cache;
+ bs->consumedBits = bs_consumedBits;
+
+ return DRFLAC_TRUE;
+}
+
+static DRFLAC_INLINE drflac_bool32 drflac__seek_rice_parts(drflac_bs* bs, drflac_uint8 riceParam)
+{
+ drflac_uint32 riceParamPlus1 = riceParam + 1;
+ drflac_uint32 riceParamPlus1MaxConsumedBits = DRFLAC_CACHE_L1_SIZE_BITS(bs) - riceParamPlus1;
+
+ /*
+ The idea here is to use local variables for the cache in an attempt to encourage the compiler to store them in registers. I have
+ no idea how this will work in practice...
+ */
+ drflac_cache_t bs_cache = bs->cache;
+ drflac_uint32 bs_consumedBits = bs->consumedBits;
+
+ /* The first thing to do is find the first unset bit. Most likely a bit will be set in the current cache line. */
+ drflac_uint32 lzcount = drflac__clz(bs_cache);
+ if (lzcount < sizeof(bs_cache)*8) {
+ /*
+ It is most likely that the riceParam part (which comes after the zero counter) is also on this cache line. When extracting
+ this, we include the set bit from the unary coded part because it simplifies cache management. This bit will be handled
+ outside of this function at a higher level.
+ */
+ extract_rice_param_part:
+ bs_cache <<= lzcount;
+ bs_consumedBits += lzcount;
+
+ if (bs_consumedBits <= riceParamPlus1MaxConsumedBits) {
+ /* Getting here means the rice parameter part is wholly contained within the current cache line. */
+ bs_cache <<= riceParamPlus1;
+ bs_consumedBits += riceParamPlus1;
+ } else {
+ /*
+ Getting here means the rice parameter part straddles the cache line. We need to read from the tail of the current cache
+ line, reload the cache, and then combine it with the head of the next cache line.
+ */
+
+ /* Before reloading the cache we need to grab the size in bits of the low part. */
+ drflac_uint32 riceParamPartLoBitCount = bs_consumedBits - riceParamPlus1MaxConsumedBits;
+ DRFLAC_ASSERT(riceParamPartLoBitCount > 0 && riceParamPartLoBitCount < 32);
+
+ /* Now reload the cache. */
+ if (bs->nextL2Line < DRFLAC_CACHE_L2_LINE_COUNT(bs)) {
+ #ifndef DR_FLAC_NO_CRC
+ drflac__update_crc16(bs);
+ #endif
+ bs_cache = drflac__be2host__cache_line(bs->cacheL2[bs->nextL2Line++]);
+ bs_consumedBits = riceParamPartLoBitCount;
+ #ifndef DR_FLAC_NO_CRC
+ bs->crc16Cache = bs_cache;
+ #endif
+ } else {
+ /* Slow path. We need to fetch more data from the client. */
+ if (!drflac__reload_cache(bs)) {
+ return DRFLAC_FALSE;
+ }
+
+ if (riceParamPartLoBitCount > DRFLAC_CACHE_L1_BITS_REMAINING(bs)) {
+ /* This happens when we get to end of stream */
+ return DRFLAC_FALSE;
+ }
+
+ bs_cache = bs->cache;
+ bs_consumedBits = bs->consumedBits + riceParamPartLoBitCount;
+ }
+
+ bs_cache <<= riceParamPartLoBitCount;
+ }
+ } else {
+ /*
+ Getting here means there are no bits set on the cache line. This is a less optimal case because we just wasted a call
+ to drflac__clz() and we need to reload the cache.
+ */
+ for (;;) {
+ if (bs->nextL2Line < DRFLAC_CACHE_L2_LINE_COUNT(bs)) {
+ #ifndef DR_FLAC_NO_CRC
+ drflac__update_crc16(bs);
+ #endif
+ bs_cache = drflac__be2host__cache_line(bs->cacheL2[bs->nextL2Line++]);
+ bs_consumedBits = 0;
+ #ifndef DR_FLAC_NO_CRC
+ bs->crc16Cache = bs_cache;
+ #endif
+ } else {
+ /* Slow path. We need to fetch more data from the client. */
+ if (!drflac__reload_cache(bs)) {
+ return DRFLAC_FALSE;
+ }
+
+ bs_cache = bs->cache;
+ bs_consumedBits = bs->consumedBits;
+ }
+
+ lzcount = drflac__clz(bs_cache);
+ if (lzcount < sizeof(bs_cache)*8) {
+ break;
+ }
+ }
+
+ goto extract_rice_param_part;
+ }
+
+ /* Make sure the cache is restored at the end of it all. */
+ bs->cache = bs_cache;
+ bs->consumedBits = bs_consumedBits;
+
+ return DRFLAC_TRUE;
+}
+
+
+static drflac_bool32 drflac__decode_samples_with_residual__rice__scalar_zeroorder(drflac_bs* bs, drflac_uint32 bitsPerSample, drflac_uint32 count, drflac_uint8 riceParam, drflac_uint32 order, drflac_int32 shift, const drflac_int32* coefficients, drflac_int32* pSamplesOut)
+{
+ drflac_uint32 t[2] = {0x00000000, 0xFFFFFFFF};
+ drflac_uint32 zeroCountPart0;
+ drflac_uint32 riceParamPart0;
+ drflac_uint32 riceParamMask;
+ drflac_uint32 i;
+
+ DRFLAC_ASSERT(bs != NULL);
+ DRFLAC_ASSERT(pSamplesOut != NULL);
+
+ (void)bitsPerSample;
+ (void)order;
+ (void)shift;
+ (void)coefficients;
+
+ riceParamMask = (drflac_uint32)~((~0UL) << riceParam);
+
+ i = 0;
+ while (i < count) {
+ /* Rice extraction. */
+ if (!drflac__read_rice_parts_x1(bs, riceParam, &zeroCountPart0, &riceParamPart0)) {
+ return DRFLAC_FALSE;
+ }
+
+ /* Rice reconstruction. */
+ riceParamPart0 &= riceParamMask;
+ riceParamPart0 |= (zeroCountPart0 << riceParam);
+ riceParamPart0 = (riceParamPart0 >> 1) ^ t[riceParamPart0 & 0x01];
+
+ pSamplesOut[i] = riceParamPart0;
+
+ i += 1;
+ }
+
+ return DRFLAC_TRUE;
+}
+
+static drflac_bool32 drflac__decode_samples_with_residual__rice__scalar(drflac_bs* bs, drflac_uint32 bitsPerSample, drflac_uint32 count, drflac_uint8 riceParam, drflac_uint32 lpcOrder, drflac_int32 lpcShift, drflac_uint32 lpcPrecision, const drflac_int32* coefficients, drflac_int32* pSamplesOut)
+{
+ drflac_uint32 t[2] = {0x00000000, 0xFFFFFFFF};
+ drflac_uint32 zeroCountPart0 = 0;
+ drflac_uint32 zeroCountPart1 = 0;
+ drflac_uint32 zeroCountPart2 = 0;
+ drflac_uint32 zeroCountPart3 = 0;
+ drflac_uint32 riceParamPart0 = 0;
+ drflac_uint32 riceParamPart1 = 0;
+ drflac_uint32 riceParamPart2 = 0;
+ drflac_uint32 riceParamPart3 = 0;
+ drflac_uint32 riceParamMask;
+ const drflac_int32* pSamplesOutEnd;
+ drflac_uint32 i;
+
+ DRFLAC_ASSERT(bs != NULL);
+ DRFLAC_ASSERT(pSamplesOut != NULL);
+
+ if (lpcOrder == 0) {
+ return drflac__decode_samples_with_residual__rice__scalar_zeroorder(bs, bitsPerSample, count, riceParam, lpcOrder, lpcShift, coefficients, pSamplesOut);
+ }
+
+ riceParamMask = (drflac_uint32)~((~0UL) << riceParam);
+ pSamplesOutEnd = pSamplesOut + (count & ~3);
+
+ if (drflac__use_64_bit_prediction(bitsPerSample, lpcOrder, lpcPrecision)) {
+ while (pSamplesOut < pSamplesOutEnd) {
+ /*
+ Rice extraction. It's faster to do this one at a time against local variables than it is to use the x4 version
+ against an array. Not sure why, but perhaps it's making more efficient use of registers?
+ */
+ if (!drflac__read_rice_parts_x1(bs, riceParam, &zeroCountPart0, &riceParamPart0) ||
+ !drflac__read_rice_parts_x1(bs, riceParam, &zeroCountPart1, &riceParamPart1) ||
+ !drflac__read_rice_parts_x1(bs, riceParam, &zeroCountPart2, &riceParamPart2) ||
+ !drflac__read_rice_parts_x1(bs, riceParam, &zeroCountPart3, &riceParamPart3)) {
+ return DRFLAC_FALSE;
+ }
+
+ riceParamPart0 &= riceParamMask;
+ riceParamPart1 &= riceParamMask;
+ riceParamPart2 &= riceParamMask;
+ riceParamPart3 &= riceParamMask;
+
+ riceParamPart0 |= (zeroCountPart0 << riceParam);
+ riceParamPart1 |= (zeroCountPart1 << riceParam);
+ riceParamPart2 |= (zeroCountPart2 << riceParam);
+ riceParamPart3 |= (zeroCountPart3 << riceParam);
+
+ riceParamPart0 = (riceParamPart0 >> 1) ^ t[riceParamPart0 & 0x01];
+ riceParamPart1 = (riceParamPart1 >> 1) ^ t[riceParamPart1 & 0x01];
+ riceParamPart2 = (riceParamPart2 >> 1) ^ t[riceParamPart2 & 0x01];
+ riceParamPart3 = (riceParamPart3 >> 1) ^ t[riceParamPart3 & 0x01];
+
+ pSamplesOut[0] = riceParamPart0 + drflac__calculate_prediction_64(lpcOrder, lpcShift, coefficients, pSamplesOut + 0);
+ pSamplesOut[1] = riceParamPart1 + drflac__calculate_prediction_64(lpcOrder, lpcShift, coefficients, pSamplesOut + 1);
+ pSamplesOut[2] = riceParamPart2 + drflac__calculate_prediction_64(lpcOrder, lpcShift, coefficients, pSamplesOut + 2);
+ pSamplesOut[3] = riceParamPart3 + drflac__calculate_prediction_64(lpcOrder, lpcShift, coefficients, pSamplesOut + 3);
+
+ pSamplesOut += 4;
+ }
+ } else {
+ while (pSamplesOut < pSamplesOutEnd) {
+ if (!drflac__read_rice_parts_x1(bs, riceParam, &zeroCountPart0, &riceParamPart0) ||
+ !drflac__read_rice_parts_x1(bs, riceParam, &zeroCountPart1, &riceParamPart1) ||
+ !drflac__read_rice_parts_x1(bs, riceParam, &zeroCountPart2, &riceParamPart2) ||
+ !drflac__read_rice_parts_x1(bs, riceParam, &zeroCountPart3, &riceParamPart3)) {
+ return DRFLAC_FALSE;
+ }
+
+ riceParamPart0 &= riceParamMask;
+ riceParamPart1 &= riceParamMask;
+ riceParamPart2 &= riceParamMask;
+ riceParamPart3 &= riceParamMask;
+
+ riceParamPart0 |= (zeroCountPart0 << riceParam);
+ riceParamPart1 |= (zeroCountPart1 << riceParam);
+ riceParamPart2 |= (zeroCountPart2 << riceParam);
+ riceParamPart3 |= (zeroCountPart3 << riceParam);
+
+ riceParamPart0 = (riceParamPart0 >> 1) ^ t[riceParamPart0 & 0x01];
+ riceParamPart1 = (riceParamPart1 >> 1) ^ t[riceParamPart1 & 0x01];
+ riceParamPart2 = (riceParamPart2 >> 1) ^ t[riceParamPart2 & 0x01];
+ riceParamPart3 = (riceParamPart3 >> 1) ^ t[riceParamPart3 & 0x01];
+
+ pSamplesOut[0] = riceParamPart0 + drflac__calculate_prediction_32(lpcOrder, lpcShift, coefficients, pSamplesOut + 0);
+ pSamplesOut[1] = riceParamPart1 + drflac__calculate_prediction_32(lpcOrder, lpcShift, coefficients, pSamplesOut + 1);
+ pSamplesOut[2] = riceParamPart2 + drflac__calculate_prediction_32(lpcOrder, lpcShift, coefficients, pSamplesOut + 2);
+ pSamplesOut[3] = riceParamPart3 + drflac__calculate_prediction_32(lpcOrder, lpcShift, coefficients, pSamplesOut + 3);
+
+ pSamplesOut += 4;
+ }
+ }
+
+ i = (count & ~3);
+ while (i < count) {
+ /* Rice extraction. */
+ if (!drflac__read_rice_parts_x1(bs, riceParam, &zeroCountPart0, &riceParamPart0)) {
+ return DRFLAC_FALSE;
+ }
+
+ /* Rice reconstruction. */
+ riceParamPart0 &= riceParamMask;
+ riceParamPart0 |= (zeroCountPart0 << riceParam);
+ riceParamPart0 = (riceParamPart0 >> 1) ^ t[riceParamPart0 & 0x01];
+ /*riceParamPart0 = (riceParamPart0 >> 1) ^ (~(riceParamPart0 & 0x01) + 1);*/
+
+ /* Sample reconstruction. */
+ if (drflac__use_64_bit_prediction(bitsPerSample, lpcOrder, lpcPrecision)) {
+ pSamplesOut[0] = riceParamPart0 + drflac__calculate_prediction_64(lpcOrder, lpcShift, coefficients, pSamplesOut + 0);
+ } else {
+ pSamplesOut[0] = riceParamPart0 + drflac__calculate_prediction_32(lpcOrder, lpcShift, coefficients, pSamplesOut + 0);
+ }
+
+ i += 1;
+ pSamplesOut += 1;
+ }
+
+ return DRFLAC_TRUE;
+}
+
+#if defined(DRFLAC_SUPPORT_SSE2)
+static DRFLAC_INLINE __m128i drflac__mm_packs_interleaved_epi32(__m128i a, __m128i b)
+{
+ __m128i r;
+
+ /* Pack. */
+ r = _mm_packs_epi32(a, b);
+
+ /* a3a2 a1a0 b3b2 b1b0 -> a3a2 b3b2 a1a0 b1b0 */
+ r = _mm_shuffle_epi32(r, _MM_SHUFFLE(3, 1, 2, 0));
+
+ /* a3a2 b3b2 a1a0 b1b0 -> a3b3 a2b2 a1b1 a0b0 */
+ r = _mm_shufflehi_epi16(r, _MM_SHUFFLE(3, 1, 2, 0));
+ r = _mm_shufflelo_epi16(r, _MM_SHUFFLE(3, 1, 2, 0));
+
+ return r;
+}
+#endif
+
+#if defined(DRFLAC_SUPPORT_SSE41)
+static DRFLAC_INLINE __m128i drflac__mm_not_si128(__m128i a)
+{
+ return _mm_xor_si128(a, _mm_cmpeq_epi32(_mm_setzero_si128(), _mm_setzero_si128()));
+}
+
+static DRFLAC_INLINE __m128i drflac__mm_hadd_epi32(__m128i x)
+{
+ __m128i x64 = _mm_add_epi32(x, _mm_shuffle_epi32(x, _MM_SHUFFLE(1, 0, 3, 2)));
+ __m128i x32 = _mm_shufflelo_epi16(x64, _MM_SHUFFLE(1, 0, 3, 2));
+ return _mm_add_epi32(x64, x32);
+}
+
+static DRFLAC_INLINE __m128i drflac__mm_hadd_epi64(__m128i x)
+{
+ return _mm_add_epi64(x, _mm_shuffle_epi32(x, _MM_SHUFFLE(1, 0, 3, 2)));
+}
+
+static DRFLAC_INLINE __m128i drflac__mm_srai_epi64(__m128i x, int count)
+{
+ /*
+ To simplify this we are assuming count < 32. This restriction allows us to work on a low side and a high side. The low side
+ is shifted with zero bits, whereas the right side is shifted with sign bits.
+ */
+ __m128i lo = _mm_srli_epi64(x, count);
+ __m128i hi = _mm_srai_epi32(x, count);
+
+ hi = _mm_and_si128(hi, _mm_set_epi32(0xFFFFFFFF, 0, 0xFFFFFFFF, 0)); /* The high part needs to have the low part cleared. */
+
+ return _mm_or_si128(lo, hi);
+}
+
+static drflac_bool32 drflac__decode_samples_with_residual__rice__sse41_32(drflac_bs* bs, drflac_uint32 count, drflac_uint8 riceParam, drflac_uint32 order, drflac_int32 shift, const drflac_int32* coefficients, drflac_int32* pSamplesOut)
+{
+ int i;
+ drflac_uint32 riceParamMask;
+ drflac_int32* pDecodedSamples = pSamplesOut;
+ drflac_int32* pDecodedSamplesEnd = pSamplesOut + (count & ~3);
+ drflac_uint32 zeroCountParts0 = 0;
+ drflac_uint32 zeroCountParts1 = 0;
+ drflac_uint32 zeroCountParts2 = 0;
+ drflac_uint32 zeroCountParts3 = 0;
+ drflac_uint32 riceParamParts0 = 0;
+ drflac_uint32 riceParamParts1 = 0;
+ drflac_uint32 riceParamParts2 = 0;
+ drflac_uint32 riceParamParts3 = 0;
+ __m128i coefficients128_0;
+ __m128i coefficients128_4;
+ __m128i coefficients128_8;
+ __m128i samples128_0;
+ __m128i samples128_4;
+ __m128i samples128_8;
+ __m128i riceParamMask128;
+
+ const drflac_uint32 t[2] = {0x00000000, 0xFFFFFFFF};
+
+ riceParamMask = (drflac_uint32)~((~0UL) << riceParam);
+ riceParamMask128 = _mm_set1_epi32(riceParamMask);
+
+ /* Pre-load. */
+ coefficients128_0 = _mm_setzero_si128();
+ coefficients128_4 = _mm_setzero_si128();
+ coefficients128_8 = _mm_setzero_si128();
+
+ samples128_0 = _mm_setzero_si128();
+ samples128_4 = _mm_setzero_si128();
+ samples128_8 = _mm_setzero_si128();
+
+ /*
+ Pre-loading the coefficients and prior samples is annoying because we need to ensure we don't try reading more than
+ what's available in the input buffers. It would be convenient to use a fall-through switch to do this, but this results
+ in strict aliasing warnings with GCC. To work around this I'm just doing something hacky. This feels a bit convoluted
+ so I think there's opportunity for this to be simplified.
+ */
+#if 1
+ {
+ int runningOrder = order;
+
+ /* 0 - 3. */
+ if (runningOrder >= 4) {
+ coefficients128_0 = _mm_loadu_si128((const __m128i*)(coefficients + 0));
+ samples128_0 = _mm_loadu_si128((const __m128i*)(pSamplesOut - 4));
+ runningOrder -= 4;
+ } else {
+ switch (runningOrder) {
+ case 3: coefficients128_0 = _mm_set_epi32(0, coefficients[2], coefficients[1], coefficients[0]); samples128_0 = _mm_set_epi32(pSamplesOut[-1], pSamplesOut[-2], pSamplesOut[-3], 0); break;
+ case 2: coefficients128_0 = _mm_set_epi32(0, 0, coefficients[1], coefficients[0]); samples128_0 = _mm_set_epi32(pSamplesOut[-1], pSamplesOut[-2], 0, 0); break;
+ case 1: coefficients128_0 = _mm_set_epi32(0, 0, 0, coefficients[0]); samples128_0 = _mm_set_epi32(pSamplesOut[-1], 0, 0, 0); break;
+ }
+ runningOrder = 0;
+ }
+
+ /* 4 - 7 */
+ if (runningOrder >= 4) {
+ coefficients128_4 = _mm_loadu_si128((const __m128i*)(coefficients + 4));
+ samples128_4 = _mm_loadu_si128((const __m128i*)(pSamplesOut - 8));
+ runningOrder -= 4;
+ } else {
+ switch (runningOrder) {
+ case 3: coefficients128_4 = _mm_set_epi32(0, coefficients[6], coefficients[5], coefficients[4]); samples128_4 = _mm_set_epi32(pSamplesOut[-5], pSamplesOut[-6], pSamplesOut[-7], 0); break;
+ case 2: coefficients128_4 = _mm_set_epi32(0, 0, coefficients[5], coefficients[4]); samples128_4 = _mm_set_epi32(pSamplesOut[-5], pSamplesOut[-6], 0, 0); break;
+ case 1: coefficients128_4 = _mm_set_epi32(0, 0, 0, coefficients[4]); samples128_4 = _mm_set_epi32(pSamplesOut[-5], 0, 0, 0); break;
+ }
+ runningOrder = 0;
+ }
+
+ /* 8 - 11 */
+ if (runningOrder == 4) {
+ coefficients128_8 = _mm_loadu_si128((const __m128i*)(coefficients + 8));
+ samples128_8 = _mm_loadu_si128((const __m128i*)(pSamplesOut - 12));
+ runningOrder -= 4;
+ } else {
+ switch (runningOrder) {
+ case 3: coefficients128_8 = _mm_set_epi32(0, coefficients[10], coefficients[9], coefficients[8]); samples128_8 = _mm_set_epi32(pSamplesOut[-9], pSamplesOut[-10], pSamplesOut[-11], 0); break;
+ case 2: coefficients128_8 = _mm_set_epi32(0, 0, coefficients[9], coefficients[8]); samples128_8 = _mm_set_epi32(pSamplesOut[-9], pSamplesOut[-10], 0, 0); break;
+ case 1: coefficients128_8 = _mm_set_epi32(0, 0, 0, coefficients[8]); samples128_8 = _mm_set_epi32(pSamplesOut[-9], 0, 0, 0); break;
+ }
+ runningOrder = 0;
+ }
+
+ /* Coefficients need to be shuffled for our streaming algorithm below to work. Samples are already in the correct order from the loading routine above. */
+ coefficients128_0 = _mm_shuffle_epi32(coefficients128_0, _MM_SHUFFLE(0, 1, 2, 3));
+ coefficients128_4 = _mm_shuffle_epi32(coefficients128_4, _MM_SHUFFLE(0, 1, 2, 3));
+ coefficients128_8 = _mm_shuffle_epi32(coefficients128_8, _MM_SHUFFLE(0, 1, 2, 3));
+ }
+#else
+ /* This causes strict-aliasing warnings with GCC. */
+ switch (order)
+ {
+ case 12: ((drflac_int32*)&coefficients128_8)[0] = coefficients[11]; ((drflac_int32*)&samples128_8)[0] = pDecodedSamples[-12];
+ case 11: ((drflac_int32*)&coefficients128_8)[1] = coefficients[10]; ((drflac_int32*)&samples128_8)[1] = pDecodedSamples[-11];
+ case 10: ((drflac_int32*)&coefficients128_8)[2] = coefficients[ 9]; ((drflac_int32*)&samples128_8)[2] = pDecodedSamples[-10];
+ case 9: ((drflac_int32*)&coefficients128_8)[3] = coefficients[ 8]; ((drflac_int32*)&samples128_8)[3] = pDecodedSamples[- 9];
+ case 8: ((drflac_int32*)&coefficients128_4)[0] = coefficients[ 7]; ((drflac_int32*)&samples128_4)[0] = pDecodedSamples[- 8];
+ case 7: ((drflac_int32*)&coefficients128_4)[1] = coefficients[ 6]; ((drflac_int32*)&samples128_4)[1] = pDecodedSamples[- 7];
+ case 6: ((drflac_int32*)&coefficients128_4)[2] = coefficients[ 5]; ((drflac_int32*)&samples128_4)[2] = pDecodedSamples[- 6];
+ case 5: ((drflac_int32*)&coefficients128_4)[3] = coefficients[ 4]; ((drflac_int32*)&samples128_4)[3] = pDecodedSamples[- 5];
+ case 4: ((drflac_int32*)&coefficients128_0)[0] = coefficients[ 3]; ((drflac_int32*)&samples128_0)[0] = pDecodedSamples[- 4];
+ case 3: ((drflac_int32*)&coefficients128_0)[1] = coefficients[ 2]; ((drflac_int32*)&samples128_0)[1] = pDecodedSamples[- 3];
+ case 2: ((drflac_int32*)&coefficients128_0)[2] = coefficients[ 1]; ((drflac_int32*)&samples128_0)[2] = pDecodedSamples[- 2];
+ case 1: ((drflac_int32*)&coefficients128_0)[3] = coefficients[ 0]; ((drflac_int32*)&samples128_0)[3] = pDecodedSamples[- 1];
+ }
+#endif
+
+ /* For this version we are doing one sample at a time. */
+ while (pDecodedSamples < pDecodedSamplesEnd) {
+ __m128i prediction128;
+ __m128i zeroCountPart128;
+ __m128i riceParamPart128;
+
+ if (!drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts0, &riceParamParts0) ||
+ !drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts1, &riceParamParts1) ||
+ !drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts2, &riceParamParts2) ||
+ !drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts3, &riceParamParts3)) {
+ return DRFLAC_FALSE;
+ }
+
+ zeroCountPart128 = _mm_set_epi32(zeroCountParts3, zeroCountParts2, zeroCountParts1, zeroCountParts0);
+ riceParamPart128 = _mm_set_epi32(riceParamParts3, riceParamParts2, riceParamParts1, riceParamParts0);
+
+ riceParamPart128 = _mm_and_si128(riceParamPart128, riceParamMask128);
+ riceParamPart128 = _mm_or_si128(riceParamPart128, _mm_slli_epi32(zeroCountPart128, riceParam));
+ riceParamPart128 = _mm_xor_si128(_mm_srli_epi32(riceParamPart128, 1), _mm_add_epi32(drflac__mm_not_si128(_mm_and_si128(riceParamPart128, _mm_set1_epi32(0x01))), _mm_set1_epi32(0x01))); /* <-- SSE2 compatible */
+ /*riceParamPart128 = _mm_xor_si128(_mm_srli_epi32(riceParamPart128, 1), _mm_mullo_epi32(_mm_and_si128(riceParamPart128, _mm_set1_epi32(0x01)), _mm_set1_epi32(0xFFFFFFFF)));*/ /* <-- Only supported from SSE4.1 and is slower in my testing... */
+
+ if (order <= 4) {
+ for (i = 0; i < 4; i += 1) {
+ prediction128 = _mm_mullo_epi32(coefficients128_0, samples128_0);
+
+ /* Horizontal add and shift. */
+ prediction128 = drflac__mm_hadd_epi32(prediction128);
+ prediction128 = _mm_srai_epi32(prediction128, shift);
+ prediction128 = _mm_add_epi32(riceParamPart128, prediction128);
+
+ samples128_0 = _mm_alignr_epi8(prediction128, samples128_0, 4);
+ riceParamPart128 = _mm_alignr_epi8(_mm_setzero_si128(), riceParamPart128, 4);
+ }
+ } else if (order <= 8) {
+ for (i = 0; i < 4; i += 1) {
+ prediction128 = _mm_mullo_epi32(coefficients128_4, samples128_4);
+ prediction128 = _mm_add_epi32(prediction128, _mm_mullo_epi32(coefficients128_0, samples128_0));
+
+ /* Horizontal add and shift. */
+ prediction128 = drflac__mm_hadd_epi32(prediction128);
+ prediction128 = _mm_srai_epi32(prediction128, shift);
+ prediction128 = _mm_add_epi32(riceParamPart128, prediction128);
+
+ samples128_4 = _mm_alignr_epi8(samples128_0, samples128_4, 4);
+ samples128_0 = _mm_alignr_epi8(prediction128, samples128_0, 4);
+ riceParamPart128 = _mm_alignr_epi8(_mm_setzero_si128(), riceParamPart128, 4);
+ }
+ } else {
+ for (i = 0; i < 4; i += 1) {
+ prediction128 = _mm_mullo_epi32(coefficients128_8, samples128_8);
+ prediction128 = _mm_add_epi32(prediction128, _mm_mullo_epi32(coefficients128_4, samples128_4));
+ prediction128 = _mm_add_epi32(prediction128, _mm_mullo_epi32(coefficients128_0, samples128_0));
+
+ /* Horizontal add and shift. */
+ prediction128 = drflac__mm_hadd_epi32(prediction128);
+ prediction128 = _mm_srai_epi32(prediction128, shift);
+ prediction128 = _mm_add_epi32(riceParamPart128, prediction128);
+
+ samples128_8 = _mm_alignr_epi8(samples128_4, samples128_8, 4);
+ samples128_4 = _mm_alignr_epi8(samples128_0, samples128_4, 4);
+ samples128_0 = _mm_alignr_epi8(prediction128, samples128_0, 4);
+ riceParamPart128 = _mm_alignr_epi8(_mm_setzero_si128(), riceParamPart128, 4);
+ }
+ }
+
+ /* We store samples in groups of 4. */
+ _mm_storeu_si128((__m128i*)pDecodedSamples, samples128_0);
+ pDecodedSamples += 4;
+ }
+
+ /* Make sure we process the last few samples. */
+ i = (count & ~3);
+ while (i < (int)count) {
+ /* Rice extraction. */
+ if (!drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts0, &riceParamParts0)) {
+ return DRFLAC_FALSE;
+ }
+
+ /* Rice reconstruction. */
+ riceParamParts0 &= riceParamMask;
+ riceParamParts0 |= (zeroCountParts0 << riceParam);
+ riceParamParts0 = (riceParamParts0 >> 1) ^ t[riceParamParts0 & 0x01];
+
+ /* Sample reconstruction. */
+ pDecodedSamples[0] = riceParamParts0 + drflac__calculate_prediction_32(order, shift, coefficients, pDecodedSamples);
+
+ i += 1;
+ pDecodedSamples += 1;
+ }
+
+ return DRFLAC_TRUE;
+}
+
+static drflac_bool32 drflac__decode_samples_with_residual__rice__sse41_64(drflac_bs* bs, drflac_uint32 count, drflac_uint8 riceParam, drflac_uint32 order, drflac_int32 shift, const drflac_int32* coefficients, drflac_int32* pSamplesOut)
+{
+ int i;
+ drflac_uint32 riceParamMask;
+ drflac_int32* pDecodedSamples = pSamplesOut;
+ drflac_int32* pDecodedSamplesEnd = pSamplesOut + (count & ~3);
+ drflac_uint32 zeroCountParts0 = 0;
+ drflac_uint32 zeroCountParts1 = 0;
+ drflac_uint32 zeroCountParts2 = 0;
+ drflac_uint32 zeroCountParts3 = 0;
+ drflac_uint32 riceParamParts0 = 0;
+ drflac_uint32 riceParamParts1 = 0;
+ drflac_uint32 riceParamParts2 = 0;
+ drflac_uint32 riceParamParts3 = 0;
+ __m128i coefficients128_0;
+ __m128i coefficients128_4;
+ __m128i coefficients128_8;
+ __m128i samples128_0;
+ __m128i samples128_4;
+ __m128i samples128_8;
+ __m128i prediction128;
+ __m128i riceParamMask128;
+
+ const drflac_uint32 t[2] = {0x00000000, 0xFFFFFFFF};
+
+ DRFLAC_ASSERT(order <= 12);
+
+ riceParamMask = (drflac_uint32)~((~0UL) << riceParam);
+ riceParamMask128 = _mm_set1_epi32(riceParamMask);
+
+ prediction128 = _mm_setzero_si128();
+
+ /* Pre-load. */
+ coefficients128_0 = _mm_setzero_si128();
+ coefficients128_4 = _mm_setzero_si128();
+ coefficients128_8 = _mm_setzero_si128();
+
+ samples128_0 = _mm_setzero_si128();
+ samples128_4 = _mm_setzero_si128();
+ samples128_8 = _mm_setzero_si128();
+
+#if 1
+ {
+ int runningOrder = order;
+
+ /* 0 - 3. */
+ if (runningOrder >= 4) {
+ coefficients128_0 = _mm_loadu_si128((const __m128i*)(coefficients + 0));
+ samples128_0 = _mm_loadu_si128((const __m128i*)(pSamplesOut - 4));
+ runningOrder -= 4;
+ } else {
+ switch (runningOrder) {
+ case 3: coefficients128_0 = _mm_set_epi32(0, coefficients[2], coefficients[1], coefficients[0]); samples128_0 = _mm_set_epi32(pSamplesOut[-1], pSamplesOut[-2], pSamplesOut[-3], 0); break;
+ case 2: coefficients128_0 = _mm_set_epi32(0, 0, coefficients[1], coefficients[0]); samples128_0 = _mm_set_epi32(pSamplesOut[-1], pSamplesOut[-2], 0, 0); break;
+ case 1: coefficients128_0 = _mm_set_epi32(0, 0, 0, coefficients[0]); samples128_0 = _mm_set_epi32(pSamplesOut[-1], 0, 0, 0); break;
+ }
+ runningOrder = 0;
+ }
+
+ /* 4 - 7 */
+ if (runningOrder >= 4) {
+ coefficients128_4 = _mm_loadu_si128((const __m128i*)(coefficients + 4));
+ samples128_4 = _mm_loadu_si128((const __m128i*)(pSamplesOut - 8));
+ runningOrder -= 4;
+ } else {
+ switch (runningOrder) {
+ case 3: coefficients128_4 = _mm_set_epi32(0, coefficients[6], coefficients[5], coefficients[4]); samples128_4 = _mm_set_epi32(pSamplesOut[-5], pSamplesOut[-6], pSamplesOut[-7], 0); break;
+ case 2: coefficients128_4 = _mm_set_epi32(0, 0, coefficients[5], coefficients[4]); samples128_4 = _mm_set_epi32(pSamplesOut[-5], pSamplesOut[-6], 0, 0); break;
+ case 1: coefficients128_4 = _mm_set_epi32(0, 0, 0, coefficients[4]); samples128_4 = _mm_set_epi32(pSamplesOut[-5], 0, 0, 0); break;
+ }
+ runningOrder = 0;
+ }
+
+ /* 8 - 11 */
+ if (runningOrder == 4) {
+ coefficients128_8 = _mm_loadu_si128((const __m128i*)(coefficients + 8));
+ samples128_8 = _mm_loadu_si128((const __m128i*)(pSamplesOut - 12));
+ runningOrder -= 4;
+ } else {
+ switch (runningOrder) {
+ case 3: coefficients128_8 = _mm_set_epi32(0, coefficients[10], coefficients[9], coefficients[8]); samples128_8 = _mm_set_epi32(pSamplesOut[-9], pSamplesOut[-10], pSamplesOut[-11], 0); break;
+ case 2: coefficients128_8 = _mm_set_epi32(0, 0, coefficients[9], coefficients[8]); samples128_8 = _mm_set_epi32(pSamplesOut[-9], pSamplesOut[-10], 0, 0); break;
+ case 1: coefficients128_8 = _mm_set_epi32(0, 0, 0, coefficients[8]); samples128_8 = _mm_set_epi32(pSamplesOut[-9], 0, 0, 0); break;
+ }
+ runningOrder = 0;
+ }
+
+ /* Coefficients need to be shuffled for our streaming algorithm below to work. Samples are already in the correct order from the loading routine above. */
+ coefficients128_0 = _mm_shuffle_epi32(coefficients128_0, _MM_SHUFFLE(0, 1, 2, 3));
+ coefficients128_4 = _mm_shuffle_epi32(coefficients128_4, _MM_SHUFFLE(0, 1, 2, 3));
+ coefficients128_8 = _mm_shuffle_epi32(coefficients128_8, _MM_SHUFFLE(0, 1, 2, 3));
+ }
+#else
+ switch (order)
+ {
+ case 12: ((drflac_int32*)&coefficients128_8)[0] = coefficients[11]; ((drflac_int32*)&samples128_8)[0] = pDecodedSamples[-12];
+ case 11: ((drflac_int32*)&coefficients128_8)[1] = coefficients[10]; ((drflac_int32*)&samples128_8)[1] = pDecodedSamples[-11];
+ case 10: ((drflac_int32*)&coefficients128_8)[2] = coefficients[ 9]; ((drflac_int32*)&samples128_8)[2] = pDecodedSamples[-10];
+ case 9: ((drflac_int32*)&coefficients128_8)[3] = coefficients[ 8]; ((drflac_int32*)&samples128_8)[3] = pDecodedSamples[- 9];
+ case 8: ((drflac_int32*)&coefficients128_4)[0] = coefficients[ 7]; ((drflac_int32*)&samples128_4)[0] = pDecodedSamples[- 8];
+ case 7: ((drflac_int32*)&coefficients128_4)[1] = coefficients[ 6]; ((drflac_int32*)&samples128_4)[1] = pDecodedSamples[- 7];
+ case 6: ((drflac_int32*)&coefficients128_4)[2] = coefficients[ 5]; ((drflac_int32*)&samples128_4)[2] = pDecodedSamples[- 6];
+ case 5: ((drflac_int32*)&coefficients128_4)[3] = coefficients[ 4]; ((drflac_int32*)&samples128_4)[3] = pDecodedSamples[- 5];
+ case 4: ((drflac_int32*)&coefficients128_0)[0] = coefficients[ 3]; ((drflac_int32*)&samples128_0)[0] = pDecodedSamples[- 4];
+ case 3: ((drflac_int32*)&coefficients128_0)[1] = coefficients[ 2]; ((drflac_int32*)&samples128_0)[1] = pDecodedSamples[- 3];
+ case 2: ((drflac_int32*)&coefficients128_0)[2] = coefficients[ 1]; ((drflac_int32*)&samples128_0)[2] = pDecodedSamples[- 2];
+ case 1: ((drflac_int32*)&coefficients128_0)[3] = coefficients[ 0]; ((drflac_int32*)&samples128_0)[3] = pDecodedSamples[- 1];
+ }
+#endif
+
+ /* For this version we are doing one sample at a time. */
+ while (pDecodedSamples < pDecodedSamplesEnd) {
+ __m128i zeroCountPart128;
+ __m128i riceParamPart128;
+
+ if (!drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts0, &riceParamParts0) ||
+ !drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts1, &riceParamParts1) ||
+ !drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts2, &riceParamParts2) ||
+ !drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts3, &riceParamParts3)) {
+ return DRFLAC_FALSE;
+ }
+
+ zeroCountPart128 = _mm_set_epi32(zeroCountParts3, zeroCountParts2, zeroCountParts1, zeroCountParts0);
+ riceParamPart128 = _mm_set_epi32(riceParamParts3, riceParamParts2, riceParamParts1, riceParamParts0);
+
+ riceParamPart128 = _mm_and_si128(riceParamPart128, riceParamMask128);
+ riceParamPart128 = _mm_or_si128(riceParamPart128, _mm_slli_epi32(zeroCountPart128, riceParam));
+ riceParamPart128 = _mm_xor_si128(_mm_srli_epi32(riceParamPart128, 1), _mm_add_epi32(drflac__mm_not_si128(_mm_and_si128(riceParamPart128, _mm_set1_epi32(1))), _mm_set1_epi32(1)));
+
+ for (i = 0; i < 4; i += 1) {
+ prediction128 = _mm_xor_si128(prediction128, prediction128); /* Reset to 0. */
+
+ switch (order)
+ {
+ case 12:
+ case 11: prediction128 = _mm_add_epi64(prediction128, _mm_mul_epi32(_mm_shuffle_epi32(coefficients128_8, _MM_SHUFFLE(1, 1, 0, 0)), _mm_shuffle_epi32(samples128_8, _MM_SHUFFLE(1, 1, 0, 0))));
+ case 10:
+ case 9: prediction128 = _mm_add_epi64(prediction128, _mm_mul_epi32(_mm_shuffle_epi32(coefficients128_8, _MM_SHUFFLE(3, 3, 2, 2)), _mm_shuffle_epi32(samples128_8, _MM_SHUFFLE(3, 3, 2, 2))));
+ case 8:
+ case 7: prediction128 = _mm_add_epi64(prediction128, _mm_mul_epi32(_mm_shuffle_epi32(coefficients128_4, _MM_SHUFFLE(1, 1, 0, 0)), _mm_shuffle_epi32(samples128_4, _MM_SHUFFLE(1, 1, 0, 0))));
+ case 6:
+ case 5: prediction128 = _mm_add_epi64(prediction128, _mm_mul_epi32(_mm_shuffle_epi32(coefficients128_4, _MM_SHUFFLE(3, 3, 2, 2)), _mm_shuffle_epi32(samples128_4, _MM_SHUFFLE(3, 3, 2, 2))));
+ case 4:
+ case 3: prediction128 = _mm_add_epi64(prediction128, _mm_mul_epi32(_mm_shuffle_epi32(coefficients128_0, _MM_SHUFFLE(1, 1, 0, 0)), _mm_shuffle_epi32(samples128_0, _MM_SHUFFLE(1, 1, 0, 0))));
+ case 2:
+ case 1: prediction128 = _mm_add_epi64(prediction128, _mm_mul_epi32(_mm_shuffle_epi32(coefficients128_0, _MM_SHUFFLE(3, 3, 2, 2)), _mm_shuffle_epi32(samples128_0, _MM_SHUFFLE(3, 3, 2, 2))));
+ }
+
+ /* Horizontal add and shift. */
+ prediction128 = drflac__mm_hadd_epi64(prediction128);
+ prediction128 = drflac__mm_srai_epi64(prediction128, shift);
+ prediction128 = _mm_add_epi32(riceParamPart128, prediction128);
+
+ /* Our value should be sitting in prediction128[0]. We need to combine this with our SSE samples. */
+ samples128_8 = _mm_alignr_epi8(samples128_4, samples128_8, 4);
+ samples128_4 = _mm_alignr_epi8(samples128_0, samples128_4, 4);
+ samples128_0 = _mm_alignr_epi8(prediction128, samples128_0, 4);
+
+ /* Slide our rice parameter down so that the value in position 0 contains the next one to process. */
+ riceParamPart128 = _mm_alignr_epi8(_mm_setzero_si128(), riceParamPart128, 4);
+ }
+
+ /* We store samples in groups of 4. */
+ _mm_storeu_si128((__m128i*)pDecodedSamples, samples128_0);
+ pDecodedSamples += 4;
+ }
+
+ /* Make sure we process the last few samples. */
+ i = (count & ~3);
+ while (i < (int)count) {
+ /* Rice extraction. */
+ if (!drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts0, &riceParamParts0)) {
+ return DRFLAC_FALSE;
+ }
+
+ /* Rice reconstruction. */
+ riceParamParts0 &= riceParamMask;
+ riceParamParts0 |= (zeroCountParts0 << riceParam);
+ riceParamParts0 = (riceParamParts0 >> 1) ^ t[riceParamParts0 & 0x01];
+
+ /* Sample reconstruction. */
+ pDecodedSamples[0] = riceParamParts0 + drflac__calculate_prediction_64(order, shift, coefficients, pDecodedSamples);
+
+ i += 1;
+ pDecodedSamples += 1;
+ }
+
+ return DRFLAC_TRUE;
+}
+
+static drflac_bool32 drflac__decode_samples_with_residual__rice__sse41(drflac_bs* bs, drflac_uint32 bitsPerSample, drflac_uint32 count, drflac_uint8 riceParam, drflac_uint32 lpcOrder, drflac_int32 lpcShift, drflac_uint32 lpcPrecision, const drflac_int32* coefficients, drflac_int32* pSamplesOut)
+{
+ DRFLAC_ASSERT(bs != NULL);
+ DRFLAC_ASSERT(pSamplesOut != NULL);
+
+ /* In my testing the order is rarely > 12, so in this case I'm going to simplify the SSE implementation by only handling order <= 12. */
+ if (lpcOrder > 0 && lpcOrder <= 12) {
+ if (drflac__use_64_bit_prediction(bitsPerSample, lpcOrder, lpcPrecision)) {
+ return drflac__decode_samples_with_residual__rice__sse41_64(bs, count, riceParam, lpcOrder, lpcShift, coefficients, pSamplesOut);
+ } else {
+ return drflac__decode_samples_with_residual__rice__sse41_32(bs, count, riceParam, lpcOrder, lpcShift, coefficients, pSamplesOut);
+ }
+ } else {
+ return drflac__decode_samples_with_residual__rice__scalar(bs, bitsPerSample, count, riceParam, lpcOrder, lpcShift, lpcPrecision, coefficients, pSamplesOut);
+ }
+}
+#endif
+
+#if defined(DRFLAC_SUPPORT_NEON)
+static DRFLAC_INLINE void drflac__vst2q_s32(drflac_int32* p, int32x4x2_t x)
+{
+ vst1q_s32(p+0, x.val[0]);
+ vst1q_s32(p+4, x.val[1]);
+}
+
+static DRFLAC_INLINE void drflac__vst2q_u32(drflac_uint32* p, uint32x4x2_t x)
+{
+ vst1q_u32(p+0, x.val[0]);
+ vst1q_u32(p+4, x.val[1]);
+}
+
+static DRFLAC_INLINE void drflac__vst2q_f32(float* p, float32x4x2_t x)
+{
+ vst1q_f32(p+0, x.val[0]);
+ vst1q_f32(p+4, x.val[1]);
+}
+
+static DRFLAC_INLINE void drflac__vst2q_s16(drflac_int16* p, int16x4x2_t x)
+{
+ vst1q_s16(p, vcombine_s16(x.val[0], x.val[1]));
+}
+
+static DRFLAC_INLINE void drflac__vst2q_u16(drflac_uint16* p, uint16x4x2_t x)
+{
+ vst1q_u16(p, vcombine_u16(x.val[0], x.val[1]));
+}
+
+static DRFLAC_INLINE int32x4_t drflac__vdupq_n_s32x4(drflac_int32 x3, drflac_int32 x2, drflac_int32 x1, drflac_int32 x0)
+{
+ drflac_int32 x[4];
+ x[3] = x3;
+ x[2] = x2;
+ x[1] = x1;
+ x[0] = x0;
+ return vld1q_s32(x);
+}
+
+static DRFLAC_INLINE int32x4_t drflac__valignrq_s32_1(int32x4_t a, int32x4_t b)
+{
+ /* Equivalent to SSE's _mm_alignr_epi8(a, b, 4) */
+
+ /* Reference */
+ /*return drflac__vdupq_n_s32x4(
+ vgetq_lane_s32(a, 0),
+ vgetq_lane_s32(b, 3),
+ vgetq_lane_s32(b, 2),
+ vgetq_lane_s32(b, 1)
+ );*/
+
+ return vextq_s32(b, a, 1);
+}
+
+static DRFLAC_INLINE uint32x4_t drflac__valignrq_u32_1(uint32x4_t a, uint32x4_t b)
+{
+ /* Equivalent to SSE's _mm_alignr_epi8(a, b, 4) */
+
+ /* Reference */
+ /*return drflac__vdupq_n_s32x4(
+ vgetq_lane_s32(a, 0),
+ vgetq_lane_s32(b, 3),
+ vgetq_lane_s32(b, 2),
+ vgetq_lane_s32(b, 1)
+ );*/
+
+ return vextq_u32(b, a, 1);
+}
+
+static DRFLAC_INLINE int32x2_t drflac__vhaddq_s32(int32x4_t x)
+{
+ /* The sum must end up in position 0. */
+
+ /* Reference */
+ /*return vdupq_n_s32(
+ vgetq_lane_s32(x, 3) +
+ vgetq_lane_s32(x, 2) +
+ vgetq_lane_s32(x, 1) +
+ vgetq_lane_s32(x, 0)
+ );*/
+
+ int32x2_t r = vadd_s32(vget_high_s32(x), vget_low_s32(x));
+ return vpadd_s32(r, r);
+}
+
+static DRFLAC_INLINE int64x1_t drflac__vhaddq_s64(int64x2_t x)
+{
+ return vadd_s64(vget_high_s64(x), vget_low_s64(x));
+}
+
+static DRFLAC_INLINE int32x4_t drflac__vrevq_s32(int32x4_t x)
+{
+ /* Reference */
+ /*return drflac__vdupq_n_s32x4(
+ vgetq_lane_s32(x, 0),
+ vgetq_lane_s32(x, 1),
+ vgetq_lane_s32(x, 2),
+ vgetq_lane_s32(x, 3)
+ );*/
+
+ return vrev64q_s32(vcombine_s32(vget_high_s32(x), vget_low_s32(x)));
+}
+
+static DRFLAC_INLINE int32x4_t drflac__vnotq_s32(int32x4_t x)
+{
+ return veorq_s32(x, vdupq_n_s32(0xFFFFFFFF));
+}
+
+static DRFLAC_INLINE uint32x4_t drflac__vnotq_u32(uint32x4_t x)
+{
+ return veorq_u32(x, vdupq_n_u32(0xFFFFFFFF));
+}
+
+static drflac_bool32 drflac__decode_samples_with_residual__rice__neon_32(drflac_bs* bs, drflac_uint32 count, drflac_uint8 riceParam, drflac_uint32 order, drflac_int32 shift, const drflac_int32* coefficients, drflac_int32* pSamplesOut)
+{
+ int i;
+ drflac_uint32 riceParamMask;
+ drflac_int32* pDecodedSamples = pSamplesOut;
+ drflac_int32* pDecodedSamplesEnd = pSamplesOut + (count & ~3);
+ drflac_uint32 zeroCountParts[4];
+ drflac_uint32 riceParamParts[4];
+ int32x4_t coefficients128_0;
+ int32x4_t coefficients128_4;
+ int32x4_t coefficients128_8;
+ int32x4_t samples128_0;
+ int32x4_t samples128_4;
+ int32x4_t samples128_8;
+ uint32x4_t riceParamMask128;
+ int32x4_t riceParam128;
+ int32x2_t shift64;
+ uint32x4_t one128;
+
+ const drflac_uint32 t[2] = {0x00000000, 0xFFFFFFFF};
+
+ riceParamMask = (drflac_uint32)~((~0UL) << riceParam);
+ riceParamMask128 = vdupq_n_u32(riceParamMask);
+
+ riceParam128 = vdupq_n_s32(riceParam);
+ shift64 = vdup_n_s32(-shift); /* Negate the shift because we'll be doing a variable shift using vshlq_s32(). */
+ one128 = vdupq_n_u32(1);
+
+ /*
+ Pre-loading the coefficients and prior samples is annoying because we need to ensure we don't try reading more than
+ what's available in the input buffers. It would be conenient to use a fall-through switch to do this, but this results
+ in strict aliasing warnings with GCC. To work around this I'm just doing something hacky. This feels a bit convoluted
+ so I think there's opportunity for this to be simplified.
+ */
+ {
+ int runningOrder = order;
+ drflac_int32 tempC[4] = {0, 0, 0, 0};
+ drflac_int32 tempS[4] = {0, 0, 0, 0};
+
+ /* 0 - 3. */
+ if (runningOrder >= 4) {
+ coefficients128_0 = vld1q_s32(coefficients + 0);
+ samples128_0 = vld1q_s32(pSamplesOut - 4);
+ runningOrder -= 4;
+ } else {
+ switch (runningOrder) {
+ case 3: tempC[2] = coefficients[2]; tempS[1] = pSamplesOut[-3]; /* fallthrough */
+ case 2: tempC[1] = coefficients[1]; tempS[2] = pSamplesOut[-2]; /* fallthrough */
+ case 1: tempC[0] = coefficients[0]; tempS[3] = pSamplesOut[-1]; /* fallthrough */
+ }
+
+ coefficients128_0 = vld1q_s32(tempC);
+ samples128_0 = vld1q_s32(tempS);
+ runningOrder = 0;
+ }
+
+ /* 4 - 7 */
+ if (runningOrder >= 4) {
+ coefficients128_4 = vld1q_s32(coefficients + 4);
+ samples128_4 = vld1q_s32(pSamplesOut - 8);
+ runningOrder -= 4;
+ } else {
+ switch (runningOrder) {
+ case 3: tempC[2] = coefficients[6]; tempS[1] = pSamplesOut[-7]; /* fallthrough */
+ case 2: tempC[1] = coefficients[5]; tempS[2] = pSamplesOut[-6]; /* fallthrough */
+ case 1: tempC[0] = coefficients[4]; tempS[3] = pSamplesOut[-5]; /* fallthrough */
+ }
+
+ coefficients128_4 = vld1q_s32(tempC);
+ samples128_4 = vld1q_s32(tempS);
+ runningOrder = 0;
+ }
+
+ /* 8 - 11 */
+ if (runningOrder == 4) {
+ coefficients128_8 = vld1q_s32(coefficients + 8);
+ samples128_8 = vld1q_s32(pSamplesOut - 12);
+ runningOrder -= 4;
+ } else {
+ switch (runningOrder) {
+ case 3: tempC[2] = coefficients[10]; tempS[1] = pSamplesOut[-11]; /* fallthrough */
+ case 2: tempC[1] = coefficients[ 9]; tempS[2] = pSamplesOut[-10]; /* fallthrough */
+ case 1: tempC[0] = coefficients[ 8]; tempS[3] = pSamplesOut[- 9]; /* fallthrough */
+ }
+
+ coefficients128_8 = vld1q_s32(tempC);
+ samples128_8 = vld1q_s32(tempS);
+ runningOrder = 0;
+ }
+
+ /* Coefficients need to be shuffled for our streaming algorithm below to work. Samples are already in the correct order from the loading routine above. */
+ coefficients128_0 = drflac__vrevq_s32(coefficients128_0);
+ coefficients128_4 = drflac__vrevq_s32(coefficients128_4);
+ coefficients128_8 = drflac__vrevq_s32(coefficients128_8);
+ }
+
+ /* For this version we are doing one sample at a time. */
+ while (pDecodedSamples < pDecodedSamplesEnd) {
+ int32x4_t prediction128;
+ int32x2_t prediction64;
+ uint32x4_t zeroCountPart128;
+ uint32x4_t riceParamPart128;
+
+ if (!drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[0], &riceParamParts[0]) ||
+ !drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[1], &riceParamParts[1]) ||
+ !drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[2], &riceParamParts[2]) ||
+ !drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[3], &riceParamParts[3])) {
+ return DRFLAC_FALSE;
+ }
+
+ zeroCountPart128 = vld1q_u32(zeroCountParts);
+ riceParamPart128 = vld1q_u32(riceParamParts);
+
+ riceParamPart128 = vandq_u32(riceParamPart128, riceParamMask128);
+ riceParamPart128 = vorrq_u32(riceParamPart128, vshlq_u32(zeroCountPart128, riceParam128));
+ riceParamPart128 = veorq_u32(vshrq_n_u32(riceParamPart128, 1), vaddq_u32(drflac__vnotq_u32(vandq_u32(riceParamPart128, one128)), one128));
+
+ if (order <= 4) {
+ for (i = 0; i < 4; i += 1) {
+ prediction128 = vmulq_s32(coefficients128_0, samples128_0);
+
+ /* Horizontal add and shift. */
+ prediction64 = drflac__vhaddq_s32(prediction128);
+ prediction64 = vshl_s32(prediction64, shift64);
+ prediction64 = vadd_s32(prediction64, vget_low_s32(vreinterpretq_s32_u32(riceParamPart128)));
+
+ samples128_0 = drflac__valignrq_s32_1(vcombine_s32(prediction64, vdup_n_s32(0)), samples128_0);
+ riceParamPart128 = drflac__valignrq_u32_1(vdupq_n_u32(0), riceParamPart128);
+ }
+ } else if (order <= 8) {
+ for (i = 0; i < 4; i += 1) {
+ prediction128 = vmulq_s32(coefficients128_4, samples128_4);
+ prediction128 = vmlaq_s32(prediction128, coefficients128_0, samples128_0);
+
+ /* Horizontal add and shift. */
+ prediction64 = drflac__vhaddq_s32(prediction128);
+ prediction64 = vshl_s32(prediction64, shift64);
+ prediction64 = vadd_s32(prediction64, vget_low_s32(vreinterpretq_s32_u32(riceParamPart128)));
+
+ samples128_4 = drflac__valignrq_s32_1(samples128_0, samples128_4);
+ samples128_0 = drflac__valignrq_s32_1(vcombine_s32(prediction64, vdup_n_s32(0)), samples128_0);
+ riceParamPart128 = drflac__valignrq_u32_1(vdupq_n_u32(0), riceParamPart128);
+ }
+ } else {
+ for (i = 0; i < 4; i += 1) {
+ prediction128 = vmulq_s32(coefficients128_8, samples128_8);
+ prediction128 = vmlaq_s32(prediction128, coefficients128_4, samples128_4);
+ prediction128 = vmlaq_s32(prediction128, coefficients128_0, samples128_0);
+
+ /* Horizontal add and shift. */
+ prediction64 = drflac__vhaddq_s32(prediction128);
+ prediction64 = vshl_s32(prediction64, shift64);
+ prediction64 = vadd_s32(prediction64, vget_low_s32(vreinterpretq_s32_u32(riceParamPart128)));
+
+ samples128_8 = drflac__valignrq_s32_1(samples128_4, samples128_8);
+ samples128_4 = drflac__valignrq_s32_1(samples128_0, samples128_4);
+ samples128_0 = drflac__valignrq_s32_1(vcombine_s32(prediction64, vdup_n_s32(0)), samples128_0);
+ riceParamPart128 = drflac__valignrq_u32_1(vdupq_n_u32(0), riceParamPart128);
+ }
+ }
+
+ /* We store samples in groups of 4. */
+ vst1q_s32(pDecodedSamples, samples128_0);
+ pDecodedSamples += 4;
+ }
+
+ /* Make sure we process the last few samples. */
+ i = (count & ~3);
+ while (i < (int)count) {
+ /* Rice extraction. */
+ if (!drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[0], &riceParamParts[0])) {
+ return DRFLAC_FALSE;
+ }
+
+ /* Rice reconstruction. */
+ riceParamParts[0] &= riceParamMask;
+ riceParamParts[0] |= (zeroCountParts[0] << riceParam);
+ riceParamParts[0] = (riceParamParts[0] >> 1) ^ t[riceParamParts[0] & 0x01];
+
+ /* Sample reconstruction. */
+ pDecodedSamples[0] = riceParamParts[0] + drflac__calculate_prediction_32(order, shift, coefficients, pDecodedSamples);
+
+ i += 1;
+ pDecodedSamples += 1;
+ }
+
+ return DRFLAC_TRUE;
+}
+
+static drflac_bool32 drflac__decode_samples_with_residual__rice__neon_64(drflac_bs* bs, drflac_uint32 count, drflac_uint8 riceParam, drflac_uint32 order, drflac_int32 shift, const drflac_int32* coefficients, drflac_int32* pSamplesOut)
+{
+ int i;
+ drflac_uint32 riceParamMask;
+ drflac_int32* pDecodedSamples = pSamplesOut;
+ drflac_int32* pDecodedSamplesEnd = pSamplesOut + (count & ~3);
+ drflac_uint32 zeroCountParts[4];
+ drflac_uint32 riceParamParts[4];
+ int32x4_t coefficients128_0;
+ int32x4_t coefficients128_4;
+ int32x4_t coefficients128_8;
+ int32x4_t samples128_0;
+ int32x4_t samples128_4;
+ int32x4_t samples128_8;
+ uint32x4_t riceParamMask128;
+ int32x4_t riceParam128;
+ int64x1_t shift64;
+ uint32x4_t one128;
+ int64x2_t prediction128 = { 0 };
+ uint32x4_t zeroCountPart128;
+ uint32x4_t riceParamPart128;
+
+ const drflac_uint32 t[2] = {0x00000000, 0xFFFFFFFF};
+
+ riceParamMask = (drflac_uint32)~((~0UL) << riceParam);
+ riceParamMask128 = vdupq_n_u32(riceParamMask);
+
+ riceParam128 = vdupq_n_s32(riceParam);
+ shift64 = vdup_n_s64(-shift); /* Negate the shift because we'll be doing a variable shift using vshlq_s32(). */
+ one128 = vdupq_n_u32(1);
+
+ /*
+ Pre-loading the coefficients and prior samples is annoying because we need to ensure we don't try reading more than
+ what's available in the input buffers. It would be convenient to use a fall-through switch to do this, but this results
+ in strict aliasing warnings with GCC. To work around this I'm just doing something hacky. This feels a bit convoluted
+ so I think there's opportunity for this to be simplified.
+ */
+ {
+ int runningOrder = order;
+ drflac_int32 tempC[4] = {0, 0, 0, 0};
+ drflac_int32 tempS[4] = {0, 0, 0, 0};
+
+ /* 0 - 3. */
+ if (runningOrder >= 4) {
+ coefficients128_0 = vld1q_s32(coefficients + 0);
+ samples128_0 = vld1q_s32(pSamplesOut - 4);
+ runningOrder -= 4;
+ } else {
+ switch (runningOrder) {
+ case 3: tempC[2] = coefficients[2]; tempS[1] = pSamplesOut[-3]; /* fallthrough */
+ case 2: tempC[1] = coefficients[1]; tempS[2] = pSamplesOut[-2]; /* fallthrough */
+ case 1: tempC[0] = coefficients[0]; tempS[3] = pSamplesOut[-1]; /* fallthrough */
+ }
+
+ coefficients128_0 = vld1q_s32(tempC);
+ samples128_0 = vld1q_s32(tempS);
+ runningOrder = 0;
+ }
+
+ /* 4 - 7 */
+ if (runningOrder >= 4) {
+ coefficients128_4 = vld1q_s32(coefficients + 4);
+ samples128_4 = vld1q_s32(pSamplesOut - 8);
+ runningOrder -= 4;
+ } else {
+ switch (runningOrder) {
+ case 3: tempC[2] = coefficients[6]; tempS[1] = pSamplesOut[-7]; /* fallthrough */
+ case 2: tempC[1] = coefficients[5]; tempS[2] = pSamplesOut[-6]; /* fallthrough */
+ case 1: tempC[0] = coefficients[4]; tempS[3] = pSamplesOut[-5]; /* fallthrough */
+ }
+
+ coefficients128_4 = vld1q_s32(tempC);
+ samples128_4 = vld1q_s32(tempS);
+ runningOrder = 0;
+ }
+
+ /* 8 - 11 */
+ if (runningOrder == 4) {
+ coefficients128_8 = vld1q_s32(coefficients + 8);
+ samples128_8 = vld1q_s32(pSamplesOut - 12);
+ runningOrder -= 4;
+ } else {
+ switch (runningOrder) {
+ case 3: tempC[2] = coefficients[10]; tempS[1] = pSamplesOut[-11]; /* fallthrough */
+ case 2: tempC[1] = coefficients[ 9]; tempS[2] = pSamplesOut[-10]; /* fallthrough */
+ case 1: tempC[0] = coefficients[ 8]; tempS[3] = pSamplesOut[- 9]; /* fallthrough */
+ }
+
+ coefficients128_8 = vld1q_s32(tempC);
+ samples128_8 = vld1q_s32(tempS);
+ runningOrder = 0;
+ }
+
+ /* Coefficients need to be shuffled for our streaming algorithm below to work. Samples are already in the correct order from the loading routine above. */
+ coefficients128_0 = drflac__vrevq_s32(coefficients128_0);
+ coefficients128_4 = drflac__vrevq_s32(coefficients128_4);
+ coefficients128_8 = drflac__vrevq_s32(coefficients128_8);
+ }
+
+ /* For this version we are doing one sample at a time. */
+ while (pDecodedSamples < pDecodedSamplesEnd) {
+ if (!drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[0], &riceParamParts[0]) ||
+ !drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[1], &riceParamParts[1]) ||
+ !drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[2], &riceParamParts[2]) ||
+ !drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[3], &riceParamParts[3])) {
+ return DRFLAC_FALSE;
+ }
+
+ zeroCountPart128 = vld1q_u32(zeroCountParts);
+ riceParamPart128 = vld1q_u32(riceParamParts);
+
+ riceParamPart128 = vandq_u32(riceParamPart128, riceParamMask128);
+ riceParamPart128 = vorrq_u32(riceParamPart128, vshlq_u32(zeroCountPart128, riceParam128));
+ riceParamPart128 = veorq_u32(vshrq_n_u32(riceParamPart128, 1), vaddq_u32(drflac__vnotq_u32(vandq_u32(riceParamPart128, one128)), one128));
+
+ for (i = 0; i < 4; i += 1) {
+ int64x1_t prediction64;
+
+ prediction128 = veorq_s64(prediction128, prediction128); /* Reset to 0. */
+ switch (order)
+ {
+ case 12:
+ case 11: prediction128 = vaddq_s64(prediction128, vmull_s32(vget_low_s32(coefficients128_8), vget_low_s32(samples128_8)));
+ case 10:
+ case 9: prediction128 = vaddq_s64(prediction128, vmull_s32(vget_high_s32(coefficients128_8), vget_high_s32(samples128_8)));
+ case 8:
+ case 7: prediction128 = vaddq_s64(prediction128, vmull_s32(vget_low_s32(coefficients128_4), vget_low_s32(samples128_4)));
+ case 6:
+ case 5: prediction128 = vaddq_s64(prediction128, vmull_s32(vget_high_s32(coefficients128_4), vget_high_s32(samples128_4)));
+ case 4:
+ case 3: prediction128 = vaddq_s64(prediction128, vmull_s32(vget_low_s32(coefficients128_0), vget_low_s32(samples128_0)));
+ case 2:
+ case 1: prediction128 = vaddq_s64(prediction128, vmull_s32(vget_high_s32(coefficients128_0), vget_high_s32(samples128_0)));
+ }
+
+ /* Horizontal add and shift. */
+ prediction64 = drflac__vhaddq_s64(prediction128);
+ prediction64 = vshl_s64(prediction64, shift64);
+ prediction64 = vadd_s64(prediction64, vdup_n_s64(vgetq_lane_u32(riceParamPart128, 0)));
+
+ /* Our value should be sitting in prediction64[0]. We need to combine this with our SSE samples. */
+ samples128_8 = drflac__valignrq_s32_1(samples128_4, samples128_8);
+ samples128_4 = drflac__valignrq_s32_1(samples128_0, samples128_4);
+ samples128_0 = drflac__valignrq_s32_1(vcombine_s32(vreinterpret_s32_s64(prediction64), vdup_n_s32(0)), samples128_0);
+
+ /* Slide our rice parameter down so that the value in position 0 contains the next one to process. */
+ riceParamPart128 = drflac__valignrq_u32_1(vdupq_n_u32(0), riceParamPart128);
+ }
+
+ /* We store samples in groups of 4. */
+ vst1q_s32(pDecodedSamples, samples128_0);
+ pDecodedSamples += 4;
+ }
+
+ /* Make sure we process the last few samples. */
+ i = (count & ~3);
+ while (i < (int)count) {
+ /* Rice extraction. */
+ if (!drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[0], &riceParamParts[0])) {
+ return DRFLAC_FALSE;
+ }
+
+ /* Rice reconstruction. */
+ riceParamParts[0] &= riceParamMask;
+ riceParamParts[0] |= (zeroCountParts[0] << riceParam);
+ riceParamParts[0] = (riceParamParts[0] >> 1) ^ t[riceParamParts[0] & 0x01];
+
+ /* Sample reconstruction. */
+ pDecodedSamples[0] = riceParamParts[0] + drflac__calculate_prediction_64(order, shift, coefficients, pDecodedSamples);
+
+ i += 1;
+ pDecodedSamples += 1;
+ }
+
+ return DRFLAC_TRUE;
+}
+
+static drflac_bool32 drflac__decode_samples_with_residual__rice__neon(drflac_bs* bs, drflac_uint32 bitsPerSample, drflac_uint32 count, drflac_uint8 riceParam, drflac_uint32 lpcOrder, drflac_int32 lpcShift, drflac_uint32 lpcPrecision, const drflac_int32* coefficients, drflac_int32* pSamplesOut)
+{
+ DRFLAC_ASSERT(bs != NULL);
+ DRFLAC_ASSERT(pSamplesOut != NULL);
+
+ /* In my testing the order is rarely > 12, so in this case I'm going to simplify the NEON implementation by only handling order <= 12. */
+ if (lpcOrder > 0 && lpcOrder <= 12) {
+ if (drflac__use_64_bit_prediction(bitsPerSample, lpcOrder, lpcPrecision)) {
+ return drflac__decode_samples_with_residual__rice__neon_64(bs, count, riceParam, lpcOrder, lpcShift, coefficients, pSamplesOut);
+ } else {
+ return drflac__decode_samples_with_residual__rice__neon_32(bs, count, riceParam, lpcOrder, lpcShift, coefficients, pSamplesOut);
+ }
+ } else {
+ return drflac__decode_samples_with_residual__rice__scalar(bs, bitsPerSample, count, riceParam, lpcOrder, lpcShift, lpcPrecision, coefficients, pSamplesOut);
+ }
+}
+#endif
+
+static drflac_bool32 drflac__decode_samples_with_residual__rice(drflac_bs* bs, drflac_uint32 bitsPerSample, drflac_uint32 count, drflac_uint8 riceParam, drflac_uint32 lpcOrder, drflac_int32 lpcShift, drflac_uint32 lpcPrecision, const drflac_int32* coefficients, drflac_int32* pSamplesOut)
+{
+#if defined(DRFLAC_SUPPORT_SSE41)
+ if (drflac__gIsSSE41Supported) {
+ return drflac__decode_samples_with_residual__rice__sse41(bs, bitsPerSample, count, riceParam, lpcOrder, lpcShift, lpcPrecision, coefficients, pSamplesOut);
+ } else
+#elif defined(DRFLAC_SUPPORT_NEON)
+ if (drflac__gIsNEONSupported) {
+ return drflac__decode_samples_with_residual__rice__neon(bs, bitsPerSample, count, riceParam, lpcOrder, lpcShift, lpcPrecision, coefficients, pSamplesOut);
+ } else
+#endif
+ {
+ /* Scalar fallback. */
+ #if 0
+ return drflac__decode_samples_with_residual__rice__reference(bs, bitsPerSample, count, riceParam, lpcOrder, lpcShift, lpcPrecision, coefficients, pSamplesOut);
+ #else
+ return drflac__decode_samples_with_residual__rice__scalar(bs, bitsPerSample, count, riceParam, lpcOrder, lpcShift, lpcPrecision, coefficients, pSamplesOut);
+ #endif
+ }
+}
+
+/* Reads and seeks past a string of residual values as Rice codes. The decoder should be sitting on the first bit of the Rice codes. */
+static drflac_bool32 drflac__read_and_seek_residual__rice(drflac_bs* bs, drflac_uint32 count, drflac_uint8 riceParam)
+{
+ drflac_uint32 i;
+
+ DRFLAC_ASSERT(bs != NULL);
+
+ for (i = 0; i < count; ++i) {
+ if (!drflac__seek_rice_parts(bs, riceParam)) {
+ return DRFLAC_FALSE;
+ }
+ }
+
+ return DRFLAC_TRUE;
+}
+
+#if defined(__clang__)
+__attribute__((no_sanitize("signed-integer-overflow")))
+#endif
+static drflac_bool32 drflac__decode_samples_with_residual__unencoded(drflac_bs* bs, drflac_uint32 bitsPerSample, drflac_uint32 count, drflac_uint8 unencodedBitsPerSample, drflac_uint32 lpcOrder, drflac_int32 lpcShift, drflac_uint32 lpcPrecision, const drflac_int32* coefficients, drflac_int32* pSamplesOut)
+{
+ drflac_uint32 i;
+
+ DRFLAC_ASSERT(bs != NULL);
+ DRFLAC_ASSERT(unencodedBitsPerSample <= 31); /* <-- unencodedBitsPerSample is a 5 bit number, so cannot exceed 31. */
+ DRFLAC_ASSERT(pSamplesOut != NULL);
+
+ for (i = 0; i < count; ++i) {
+ if (unencodedBitsPerSample > 0) {
+ if (!drflac__read_int32(bs, unencodedBitsPerSample, pSamplesOut + i)) {
+ return DRFLAC_FALSE;
+ }
+ } else {
+ pSamplesOut[i] = 0;
+ }
+
+ if (drflac__use_64_bit_prediction(bitsPerSample, lpcOrder, lpcPrecision)) {
+ pSamplesOut[i] += drflac__calculate_prediction_64(lpcOrder, lpcShift, coefficients, pSamplesOut + i);
+ } else {
+ pSamplesOut[i] += drflac__calculate_prediction_32(lpcOrder, lpcShift, coefficients, pSamplesOut + i);
+ }
+ }
+
+ return DRFLAC_TRUE;
+}
+
+
+/*
+Reads and decodes the residual for the sub-frame the decoder is currently sitting on. This function should be called
+when the decoder is sitting at the very start of the RESIDUAL block. The first <order> residuals will be ignored. The
+<blockSize> and <order> parameters are used to determine how many residual values need to be decoded.
+*/
+static drflac_bool32 drflac__decode_samples_with_residual(drflac_bs* bs, drflac_uint32 bitsPerSample, drflac_uint32 blockSize, drflac_uint32 lpcOrder, drflac_int32 lpcShift, drflac_uint32 lpcPrecision, const drflac_int32* coefficients, drflac_int32* pDecodedSamples)
+{
+ drflac_uint8 residualMethod;
+ drflac_uint8 partitionOrder;
+ drflac_uint32 samplesInPartition;
+ drflac_uint32 partitionsRemaining;
+
+ DRFLAC_ASSERT(bs != NULL);
+ DRFLAC_ASSERT(blockSize != 0);
+ DRFLAC_ASSERT(pDecodedSamples != NULL); /* <-- Should we allow NULL, in which case we just seek past the residual rather than do a full decode? */
+
+ if (!drflac__read_uint8(bs, 2, &residualMethod)) {
+ return DRFLAC_FALSE;
+ }
+
+ if (residualMethod != DRFLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE && residualMethod != DRFLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE2) {
+ return DRFLAC_FALSE; /* Unknown or unsupported residual coding method. */
+ }
+
+ /* Ignore the first <order> values. */
+ pDecodedSamples += lpcOrder;
+
+ if (!drflac__read_uint8(bs, 4, &partitionOrder)) {
+ return DRFLAC_FALSE;
+ }
+
+ /*
+ From the FLAC spec:
+ The Rice partition order in a Rice-coded residual section must be less than or equal to 8.
+ */
+ if (partitionOrder > 8) {
+ return DRFLAC_FALSE;
+ }
+
+ /* Validation check. */
+ if ((blockSize / (1 << partitionOrder)) < lpcOrder) {
+ return DRFLAC_FALSE;
+ }
+
+ samplesInPartition = (blockSize / (1 << partitionOrder)) - lpcOrder;
+ partitionsRemaining = (1 << partitionOrder);
+ for (;;) {
+ drflac_uint8 riceParam = 0;
+ if (residualMethod == DRFLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE) {
+ if (!drflac__read_uint8(bs, 4, &riceParam)) {
+ return DRFLAC_FALSE;
+ }
+ if (riceParam == 15) {
+ riceParam = 0xFF;
+ }
+ } else if (residualMethod == DRFLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE2) {
+ if (!drflac__read_uint8(bs, 5, &riceParam)) {
+ return DRFLAC_FALSE;
+ }
+ if (riceParam == 31) {
+ riceParam = 0xFF;
+ }
+ }
+
+ if (riceParam != 0xFF) {
+ if (!drflac__decode_samples_with_residual__rice(bs, bitsPerSample, samplesInPartition, riceParam, lpcOrder, lpcShift, lpcPrecision, coefficients, pDecodedSamples)) {
+ return DRFLAC_FALSE;
+ }
+ } else {
+ drflac_uint8 unencodedBitsPerSample = 0;
+ if (!drflac__read_uint8(bs, 5, &unencodedBitsPerSample)) {
+ return DRFLAC_FALSE;
+ }
+
+ if (!drflac__decode_samples_with_residual__unencoded(bs, bitsPerSample, samplesInPartition, unencodedBitsPerSample, lpcOrder, lpcShift, lpcPrecision, coefficients, pDecodedSamples)) {
+ return DRFLAC_FALSE;
+ }
+ }
+
+ pDecodedSamples += samplesInPartition;
+
+ if (partitionsRemaining == 1) {
+ break;
+ }
+
+ partitionsRemaining -= 1;
+
+ if (partitionOrder != 0) {
+ samplesInPartition = blockSize / (1 << partitionOrder);
+ }
+ }
+
+ return DRFLAC_TRUE;
+}
+
+/*
+Reads and seeks past the residual for the sub-frame the decoder is currently sitting on. This function should be called
+when the decoder is sitting at the very start of the RESIDUAL block. The first <order> residuals will be set to 0. The
+<blockSize> and <order> parameters are used to determine how many residual values need to be decoded.
+*/
+static drflac_bool32 drflac__read_and_seek_residual(drflac_bs* bs, drflac_uint32 blockSize, drflac_uint32 order)
+{
+ drflac_uint8 residualMethod;
+ drflac_uint8 partitionOrder;
+ drflac_uint32 samplesInPartition;
+ drflac_uint32 partitionsRemaining;
+
+ DRFLAC_ASSERT(bs != NULL);
+ DRFLAC_ASSERT(blockSize != 0);
+
+ if (!drflac__read_uint8(bs, 2, &residualMethod)) {
+ return DRFLAC_FALSE;
+ }
+
+ if (residualMethod != DRFLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE && residualMethod != DRFLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE2) {
+ return DRFLAC_FALSE; /* Unknown or unsupported residual coding method. */
+ }
+
+ if (!drflac__read_uint8(bs, 4, &partitionOrder)) {
+ return DRFLAC_FALSE;
+ }
+
+ /*
+ From the FLAC spec:
+ The Rice partition order in a Rice-coded residual section must be less than or equal to 8.
+ */
+ if (partitionOrder > 8) {
+ return DRFLAC_FALSE;
+ }
+
+ /* Validation check. */
+ if ((blockSize / (1 << partitionOrder)) <= order) {
+ return DRFLAC_FALSE;
+ }
+
+ samplesInPartition = (blockSize / (1 << partitionOrder)) - order;
+ partitionsRemaining = (1 << partitionOrder);
+ for (;;)
+ {
+ drflac_uint8 riceParam = 0;
+ if (residualMethod == DRFLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE) {
+ if (!drflac__read_uint8(bs, 4, &riceParam)) {
+ return DRFLAC_FALSE;
+ }
+ if (riceParam == 15) {
+ riceParam = 0xFF;
+ }
+ } else if (residualMethod == DRFLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE2) {
+ if (!drflac__read_uint8(bs, 5, &riceParam)) {
+ return DRFLAC_FALSE;
+ }
+ if (riceParam == 31) {
+ riceParam = 0xFF;
+ }
+ }
+
+ if (riceParam != 0xFF) {
+ if (!drflac__read_and_seek_residual__rice(bs, samplesInPartition, riceParam)) {
+ return DRFLAC_FALSE;
+ }
+ } else {
+ drflac_uint8 unencodedBitsPerSample = 0;
+ if (!drflac__read_uint8(bs, 5, &unencodedBitsPerSample)) {
+ return DRFLAC_FALSE;
+ }
+
+ if (!drflac__seek_bits(bs, unencodedBitsPerSample * samplesInPartition)) {
+ return DRFLAC_FALSE;
+ }
+ }
+
+
+ if (partitionsRemaining == 1) {
+ break;
+ }
+
+ partitionsRemaining -= 1;
+ samplesInPartition = blockSize / (1 << partitionOrder);
+ }
+
+ return DRFLAC_TRUE;
+}
+
+
+static drflac_bool32 drflac__decode_samples__constant(drflac_bs* bs, drflac_uint32 blockSize, drflac_uint32 subframeBitsPerSample, drflac_int32* pDecodedSamples)
+{
+ drflac_uint32 i;
+
+ /* Only a single sample needs to be decoded here. */
+ drflac_int32 sample;
+ if (!drflac__read_int32(bs, subframeBitsPerSample, &sample)) {
+ return DRFLAC_FALSE;
+ }
+
+ /*
+ We don't really need to expand this, but it does simplify the process of reading samples. If this becomes a performance issue (unlikely)
+ we'll want to look at a more efficient way.
+ */
+ for (i = 0; i < blockSize; ++i) {
+ pDecodedSamples[i] = sample;
+ }
+
+ return DRFLAC_TRUE;
+}
+
+static drflac_bool32 drflac__decode_samples__verbatim(drflac_bs* bs, drflac_uint32 blockSize, drflac_uint32 subframeBitsPerSample, drflac_int32* pDecodedSamples)
+{
+ drflac_uint32 i;
+
+ for (i = 0; i < blockSize; ++i) {
+ drflac_int32 sample;
+ if (!drflac__read_int32(bs, subframeBitsPerSample, &sample)) {
+ return DRFLAC_FALSE;
+ }
+
+ pDecodedSamples[i] = sample;
+ }
+
+ return DRFLAC_TRUE;
+}
+
+static drflac_bool32 drflac__decode_samples__fixed(drflac_bs* bs, drflac_uint32 blockSize, drflac_uint32 subframeBitsPerSample, drflac_uint8 lpcOrder, drflac_int32* pDecodedSamples)
+{
+ drflac_uint32 i;
+
+ static drflac_int32 lpcCoefficientsTable[5][4] = {
+ {0, 0, 0, 0},
+ {1, 0, 0, 0},
+ {2, -1, 0, 0},
+ {3, -3, 1, 0},
+ {4, -6, 4, -1}
+ };
+
+ /* Warm up samples and coefficients. */
+ for (i = 0; i < lpcOrder; ++i) {
+ drflac_int32 sample;
+ if (!drflac__read_int32(bs, subframeBitsPerSample, &sample)) {
+ return DRFLAC_FALSE;
+ }
+
+ pDecodedSamples[i] = sample;
+ }
+
+ if (!drflac__decode_samples_with_residual(bs, subframeBitsPerSample, blockSize, lpcOrder, 0, 4, lpcCoefficientsTable[lpcOrder], pDecodedSamples)) {
+ return DRFLAC_FALSE;
+ }
+
+ return DRFLAC_TRUE;
+}
+
+static drflac_bool32 drflac__decode_samples__lpc(drflac_bs* bs, drflac_uint32 blockSize, drflac_uint32 bitsPerSample, drflac_uint8 lpcOrder, drflac_int32* pDecodedSamples)
+{
+ drflac_uint8 i;
+ drflac_uint8 lpcPrecision;
+ drflac_int8 lpcShift;
+ drflac_int32 coefficients[32];
+
+ /* Warm up samples. */
+ for (i = 0; i < lpcOrder; ++i) {
+ drflac_int32 sample;
+ if (!drflac__read_int32(bs, bitsPerSample, &sample)) {
+ return DRFLAC_FALSE;
+ }
+
+ pDecodedSamples[i] = sample;
+ }
+
+ if (!drflac__read_uint8(bs, 4, &lpcPrecision)) {
+ return DRFLAC_FALSE;
+ }
+ if (lpcPrecision == 15) {
+ return DRFLAC_FALSE; /* Invalid. */
+ }
+ lpcPrecision += 1;
+
+ if (!drflac__read_int8(bs, 5, &lpcShift)) {
+ return DRFLAC_FALSE;
+ }
+
+ /*
+ From the FLAC specification:
+
+ Quantized linear predictor coefficient shift needed in bits (NOTE: this number is signed two's-complement)
+
+ Emphasis on the "signed two's-complement". In practice there does not seem to be any encoders nor decoders supporting negative shifts. For now dr_flac is
+ not going to support negative shifts as I don't have any reference files. However, when a reference file comes through I will consider adding support.
+ */
+ if (lpcShift < 0) {
+ return DRFLAC_FALSE;
+ }
+
+ DRFLAC_ZERO_MEMORY(coefficients, sizeof(coefficients));
+ for (i = 0; i < lpcOrder; ++i) {
+ if (!drflac__read_int32(bs, lpcPrecision, coefficients + i)) {
+ return DRFLAC_FALSE;
+ }
+ }
+
+ if (!drflac__decode_samples_with_residual(bs, bitsPerSample, blockSize, lpcOrder, lpcShift, lpcPrecision, coefficients, pDecodedSamples)) {
+ return DRFLAC_FALSE;
+ }
+
+ return DRFLAC_TRUE;
+}
+
+
+static drflac_bool32 drflac__read_next_flac_frame_header(drflac_bs* bs, drflac_uint8 streaminfoBitsPerSample, drflac_frame_header* header)
+{
+ const drflac_uint32 sampleRateTable[12] = {0, 88200, 176400, 192000, 8000, 16000, 22050, 24000, 32000, 44100, 48000, 96000};
+ const drflac_uint8 bitsPerSampleTable[8] = {0, 8, 12, (drflac_uint8)-1, 16, 20, 24, (drflac_uint8)-1}; /* -1 = reserved. */
+
+ DRFLAC_ASSERT(bs != NULL);
+ DRFLAC_ASSERT(header != NULL);
+
+ /* Keep looping until we find a valid sync code. */
+ for (;;) {
+ drflac_uint8 crc8 = 0xCE; /* 0xCE = drflac_crc8(0, 0x3FFE, 14); */
+ drflac_uint8 reserved = 0;
+ drflac_uint8 blockingStrategy = 0;
+ drflac_uint8 blockSize = 0;
+ drflac_uint8 sampleRate = 0;
+ drflac_uint8 channelAssignment = 0;
+ drflac_uint8 bitsPerSample = 0;
+ drflac_bool32 isVariableBlockSize;
+
+ if (!drflac__find_and_seek_to_next_sync_code(bs)) {
+ return DRFLAC_FALSE;
+ }
+
+ if (!drflac__read_uint8(bs, 1, &reserved)) {
+ return DRFLAC_FALSE;
+ }
+ if (reserved == 1) {
+ continue;
+ }
+ crc8 = drflac_crc8(crc8, reserved, 1);
+
+ if (!drflac__read_uint8(bs, 1, &blockingStrategy)) {
+ return DRFLAC_FALSE;
+ }
+ crc8 = drflac_crc8(crc8, blockingStrategy, 1);
+
+ if (!drflac__read_uint8(bs, 4, &blockSize)) {
+ return DRFLAC_FALSE;
+ }
+ if (blockSize == 0) {
+ continue;
+ }
+ crc8 = drflac_crc8(crc8, blockSize, 4);
+
+ if (!drflac__read_uint8(bs, 4, &sampleRate)) {
+ return DRFLAC_FALSE;
+ }
+ crc8 = drflac_crc8(crc8, sampleRate, 4);
+
+ if (!drflac__read_uint8(bs, 4, &channelAssignment)) {
+ return DRFLAC_FALSE;
+ }
+ if (channelAssignment > 10) {
+ continue;
+ }
+ crc8 = drflac_crc8(crc8, channelAssignment, 4);
+
+ if (!drflac__read_uint8(bs, 3, &bitsPerSample)) {
+ return DRFLAC_FALSE;
+ }
+ if (bitsPerSample == 3 || bitsPerSample == 7) {
+ continue;
+ }
+ crc8 = drflac_crc8(crc8, bitsPerSample, 3);
+
+
+ if (!drflac__read_uint8(bs, 1, &reserved)) {
+ return DRFLAC_FALSE;
+ }
+ if (reserved == 1) {
+ continue;
+ }
+ crc8 = drflac_crc8(crc8, reserved, 1);
+
+
+ isVariableBlockSize = blockingStrategy == 1;
+ if (isVariableBlockSize) {
+ drflac_uint64 pcmFrameNumber;
+ drflac_result result = drflac__read_utf8_coded_number(bs, &pcmFrameNumber, &crc8);
+ if (result != DRFLAC_SUCCESS) {
+ if (result == DRFLAC_AT_END) {
+ return DRFLAC_FALSE;
+ } else {
+ continue;
+ }
+ }
+ header->flacFrameNumber = 0;
+ header->pcmFrameNumber = pcmFrameNumber;
+ } else {
+ drflac_uint64 flacFrameNumber = 0;
+ drflac_result result = drflac__read_utf8_coded_number(bs, &flacFrameNumber, &crc8);
+ if (result != DRFLAC_SUCCESS) {
+ if (result == DRFLAC_AT_END) {
+ return DRFLAC_FALSE;
+ } else {
+ continue;
+ }
+ }
+ header->flacFrameNumber = (drflac_uint32)flacFrameNumber; /* <-- Safe cast. */
+ header->pcmFrameNumber = 0;
+ }
+
+
+ DRFLAC_ASSERT(blockSize > 0);
+ if (blockSize == 1) {
+ header->blockSizeInPCMFrames = 192;
+ } else if (blockSize <= 5) {
+ DRFLAC_ASSERT(blockSize >= 2);
+ header->blockSizeInPCMFrames = 576 * (1 << (blockSize - 2));
+ } else if (blockSize == 6) {
+ if (!drflac__read_uint16(bs, 8, &header->blockSizeInPCMFrames)) {
+ return DRFLAC_FALSE;
+ }
+ crc8 = drflac_crc8(crc8, header->blockSizeInPCMFrames, 8);
+ header->blockSizeInPCMFrames += 1;
+ } else if (blockSize == 7) {
+ if (!drflac__read_uint16(bs, 16, &header->blockSizeInPCMFrames)) {
+ return DRFLAC_FALSE;
+ }
+ crc8 = drflac_crc8(crc8, header->blockSizeInPCMFrames, 16);
+ if (header->blockSizeInPCMFrames == 0xFFFF) {
+ return DRFLAC_FALSE; /* Frame is too big. This is the size of the frame minus 1. The STREAMINFO block defines the max block size which is 16-bits. Adding one will make it 17 bits and therefore too big. */
+ }
+ header->blockSizeInPCMFrames += 1;
+ } else {
+ DRFLAC_ASSERT(blockSize >= 8);
+ header->blockSizeInPCMFrames = 256 * (1 << (blockSize - 8));
+ }
+
+
+ if (sampleRate <= 11) {
+ header->sampleRate = sampleRateTable[sampleRate];
+ } else if (sampleRate == 12) {
+ if (!drflac__read_uint32(bs, 8, &header->sampleRate)) {
+ return DRFLAC_FALSE;
+ }
+ crc8 = drflac_crc8(crc8, header->sampleRate, 8);
+ header->sampleRate *= 1000;
+ } else if (sampleRate == 13) {
+ if (!drflac__read_uint32(bs, 16, &header->sampleRate)) {
+ return DRFLAC_FALSE;
+ }
+ crc8 = drflac_crc8(crc8, header->sampleRate, 16);
+ } else if (sampleRate == 14) {
+ if (!drflac__read_uint32(bs, 16, &header->sampleRate)) {
+ return DRFLAC_FALSE;
+ }
+ crc8 = drflac_crc8(crc8, header->sampleRate, 16);
+ header->sampleRate *= 10;
+ } else {
+ continue; /* Invalid. Assume an invalid block. */
+ }
+
+
+ header->channelAssignment = channelAssignment;
+
+ header->bitsPerSample = bitsPerSampleTable[bitsPerSample];
+ if (header->bitsPerSample == 0) {
+ header->bitsPerSample = streaminfoBitsPerSample;
+ }
+
+ if (header->bitsPerSample != streaminfoBitsPerSample) {
+ /* If this subframe has a different bitsPerSample then streaminfo or the first frame, reject it */
+ return DRFLAC_FALSE;
+ }
+
+ if (!drflac__read_uint8(bs, 8, &header->crc8)) {
+ return DRFLAC_FALSE;
+ }
+
+#ifndef DR_FLAC_NO_CRC
+ if (header->crc8 != crc8) {
+ continue; /* CRC mismatch. Loop back to the top and find the next sync code. */
+ }
+#endif
+ return DRFLAC_TRUE;
+ }
+}
+
+static drflac_bool32 drflac__read_subframe_header(drflac_bs* bs, drflac_subframe* pSubframe)
+{
+ drflac_uint8 header;
+ int type;
+
+ if (!drflac__read_uint8(bs, 8, &header)) {
+ return DRFLAC_FALSE;
+ }
+
+ /* First bit should always be 0. */
+ if ((header & 0x80) != 0) {
+ return DRFLAC_FALSE;
+ }
+
+ type = (header & 0x7E) >> 1;
+ if (type == 0) {
+ pSubframe->subframeType = DRFLAC_SUBFRAME_CONSTANT;
+ } else if (type == 1) {
+ pSubframe->subframeType = DRFLAC_SUBFRAME_VERBATIM;
+ } else {
+ if ((type & 0x20) != 0) {
+ pSubframe->subframeType = DRFLAC_SUBFRAME_LPC;
+ pSubframe->lpcOrder = (drflac_uint8)(type & 0x1F) + 1;
+ } else if ((type & 0x08) != 0) {
+ pSubframe->subframeType = DRFLAC_SUBFRAME_FIXED;
+ pSubframe->lpcOrder = (drflac_uint8)(type & 0x07);
+ if (pSubframe->lpcOrder > 4) {
+ pSubframe->subframeType = DRFLAC_SUBFRAME_RESERVED;
+ pSubframe->lpcOrder = 0;
+ }
+ } else {
+ pSubframe->subframeType = DRFLAC_SUBFRAME_RESERVED;
+ }
+ }
+
+ if (pSubframe->subframeType == DRFLAC_SUBFRAME_RESERVED) {
+ return DRFLAC_FALSE;
+ }
+
+ /* Wasted bits per sample. */
+ pSubframe->wastedBitsPerSample = 0;
+ if ((header & 0x01) == 1) {
+ unsigned int wastedBitsPerSample;
+ if (!drflac__seek_past_next_set_bit(bs, &wastedBitsPerSample)) {
+ return DRFLAC_FALSE;
+ }
+ pSubframe->wastedBitsPerSample = (drflac_uint8)wastedBitsPerSample + 1;
+ }
+
+ return DRFLAC_TRUE;
+}
+
+static drflac_bool32 drflac__decode_subframe(drflac_bs* bs, drflac_frame* frame, int subframeIndex, drflac_int32* pDecodedSamplesOut)
+{
+ drflac_subframe* pSubframe;
+ drflac_uint32 subframeBitsPerSample;
+
+ DRFLAC_ASSERT(bs != NULL);
+ DRFLAC_ASSERT(frame != NULL);
+
+ pSubframe = frame->subframes + subframeIndex;
+ if (!drflac__read_subframe_header(bs, pSubframe)) {
+ return DRFLAC_FALSE;
+ }
+
+ /* Side channels require an extra bit per sample. Took a while to figure that one out... */
+ subframeBitsPerSample = frame->header.bitsPerSample;
+ if ((frame->header.channelAssignment == DRFLAC_CHANNEL_ASSIGNMENT_LEFT_SIDE || frame->header.channelAssignment == DRFLAC_CHANNEL_ASSIGNMENT_MID_SIDE) && subframeIndex == 1) {
+ subframeBitsPerSample += 1;
+ } else if (frame->header.channelAssignment == DRFLAC_CHANNEL_ASSIGNMENT_RIGHT_SIDE && subframeIndex == 0) {
+ subframeBitsPerSample += 1;
+ }
+
+ if (subframeBitsPerSample > 32) {
+ /* libFLAC and ffmpeg reject 33-bit subframes as well */
+ return DRFLAC_FALSE;
+ }
+
+ /* Need to handle wasted bits per sample. */
+ if (pSubframe->wastedBitsPerSample >= subframeBitsPerSample) {
+ return DRFLAC_FALSE;
+ }
+ subframeBitsPerSample -= pSubframe->wastedBitsPerSample;
+
+ pSubframe->pSamplesS32 = pDecodedSamplesOut;
+
+ switch (pSubframe->subframeType)
+ {
+ case DRFLAC_SUBFRAME_CONSTANT:
+ {
+ drflac__decode_samples__constant(bs, frame->header.blockSizeInPCMFrames, subframeBitsPerSample, pSubframe->pSamplesS32);
+ } break;
+
+ case DRFLAC_SUBFRAME_VERBATIM:
+ {
+ drflac__decode_samples__verbatim(bs, frame->header.blockSizeInPCMFrames, subframeBitsPerSample, pSubframe->pSamplesS32);
+ } break;
+
+ case DRFLAC_SUBFRAME_FIXED:
+ {
+ drflac__decode_samples__fixed(bs, frame->header.blockSizeInPCMFrames, subframeBitsPerSample, pSubframe->lpcOrder, pSubframe->pSamplesS32);
+ } break;
+
+ case DRFLAC_SUBFRAME_LPC:
+ {
+ drflac__decode_samples__lpc(bs, frame->header.blockSizeInPCMFrames, subframeBitsPerSample, pSubframe->lpcOrder, pSubframe->pSamplesS32);
+ } break;
+
+ default: return DRFLAC_FALSE;
+ }
+
+ return DRFLAC_TRUE;
+}
+
+static drflac_bool32 drflac__seek_subframe(drflac_bs* bs, drflac_frame* frame, int subframeIndex)
+{
+ drflac_subframe* pSubframe;
+ drflac_uint32 subframeBitsPerSample;
+
+ DRFLAC_ASSERT(bs != NULL);
+ DRFLAC_ASSERT(frame != NULL);
+
+ pSubframe = frame->subframes + subframeIndex;
+ if (!drflac__read_subframe_header(bs, pSubframe)) {
+ return DRFLAC_FALSE;
+ }
+
+ /* Side channels require an extra bit per sample. Took a while to figure that one out... */
+ subframeBitsPerSample = frame->header.bitsPerSample;
+ if ((frame->header.channelAssignment == DRFLAC_CHANNEL_ASSIGNMENT_LEFT_SIDE || frame->header.channelAssignment == DRFLAC_CHANNEL_ASSIGNMENT_MID_SIDE) && subframeIndex == 1) {
+ subframeBitsPerSample += 1;
+ } else if (frame->header.channelAssignment == DRFLAC_CHANNEL_ASSIGNMENT_RIGHT_SIDE && subframeIndex == 0) {
+ subframeBitsPerSample += 1;
+ }
+
+ /* Need to handle wasted bits per sample. */
+ if (pSubframe->wastedBitsPerSample >= subframeBitsPerSample) {
+ return DRFLAC_FALSE;
+ }
+ subframeBitsPerSample -= pSubframe->wastedBitsPerSample;
+
+ pSubframe->pSamplesS32 = NULL;
+
+ switch (pSubframe->subframeType)
+ {
+ case DRFLAC_SUBFRAME_CONSTANT:
+ {
+ if (!drflac__seek_bits(bs, subframeBitsPerSample)) {
+ return DRFLAC_FALSE;
+ }
+ } break;
+
+ case DRFLAC_SUBFRAME_VERBATIM:
+ {
+ unsigned int bitsToSeek = frame->header.blockSizeInPCMFrames * subframeBitsPerSample;
+ if (!drflac__seek_bits(bs, bitsToSeek)) {
+ return DRFLAC_FALSE;
+ }
+ } break;
+
+ case DRFLAC_SUBFRAME_FIXED:
+ {
+ unsigned int bitsToSeek = pSubframe->lpcOrder * subframeBitsPerSample;
+ if (!drflac__seek_bits(bs, bitsToSeek)) {
+ return DRFLAC_FALSE;
+ }
+
+ if (!drflac__read_and_seek_residual(bs, frame->header.blockSizeInPCMFrames, pSubframe->lpcOrder)) {
+ return DRFLAC_FALSE;
+ }
+ } break;
+
+ case DRFLAC_SUBFRAME_LPC:
+ {
+ drflac_uint8 lpcPrecision;
+
+ unsigned int bitsToSeek = pSubframe->lpcOrder * subframeBitsPerSample;
+ if (!drflac__seek_bits(bs, bitsToSeek)) {
+ return DRFLAC_FALSE;
+ }
+
+ if (!drflac__read_uint8(bs, 4, &lpcPrecision)) {
+ return DRFLAC_FALSE;
+ }
+ if (lpcPrecision == 15) {
+ return DRFLAC_FALSE; /* Invalid. */
+ }
+ lpcPrecision += 1;
+
+
+ bitsToSeek = (pSubframe->lpcOrder * lpcPrecision) + 5; /* +5 for shift. */
+ if (!drflac__seek_bits(bs, bitsToSeek)) {
+ return DRFLAC_FALSE;
+ }
+
+ if (!drflac__read_and_seek_residual(bs, frame->header.blockSizeInPCMFrames, pSubframe->lpcOrder)) {
+ return DRFLAC_FALSE;
+ }
+ } break;
+
+ default: return DRFLAC_FALSE;
+ }
+
+ return DRFLAC_TRUE;
+}
+
+
+static DRFLAC_INLINE drflac_uint8 drflac__get_channel_count_from_channel_assignment(drflac_int8 channelAssignment)
+{
+ drflac_uint8 lookup[] = {1, 2, 3, 4, 5, 6, 7, 8, 2, 2, 2};
+
+ DRFLAC_ASSERT(channelAssignment <= 10);
+ return lookup[channelAssignment];
+}
+
+static drflac_result drflac__decode_flac_frame(drflac* pFlac)
+{
+ int channelCount;
+ int i;
+ drflac_uint8 paddingSizeInBits;
+ drflac_uint16 desiredCRC16;
+#ifndef DR_FLAC_NO_CRC
+ drflac_uint16 actualCRC16;
+#endif
+
+ /* This function should be called while the stream is sitting on the first byte after the frame header. */
+ DRFLAC_ZERO_MEMORY(pFlac->currentFLACFrame.subframes, sizeof(pFlac->currentFLACFrame.subframes));
+
+ /* The frame block size must never be larger than the maximum block size defined by the FLAC stream. */
+ if (pFlac->currentFLACFrame.header.blockSizeInPCMFrames > pFlac->maxBlockSizeInPCMFrames) {
+ return DRFLAC_ERROR;
+ }
+
+ /* The number of channels in the frame must match the channel count from the STREAMINFO block. */
+ channelCount = drflac__get_channel_count_from_channel_assignment(pFlac->currentFLACFrame.header.channelAssignment);
+ if (channelCount != (int)pFlac->channels) {
+ return DRFLAC_ERROR;
+ }
+
+ for (i = 0; i < channelCount; ++i) {
+ if (!drflac__decode_subframe(&pFlac->bs, &pFlac->currentFLACFrame, i, pFlac->pDecodedSamples + (pFlac->currentFLACFrame.header.blockSizeInPCMFrames * i))) {
+ return DRFLAC_ERROR;
+ }
+ }
+
+ paddingSizeInBits = (drflac_uint8)(DRFLAC_CACHE_L1_BITS_REMAINING(&pFlac->bs) & 7);
+ if (paddingSizeInBits > 0) {
+ drflac_uint8 padding = 0;
+ if (!drflac__read_uint8(&pFlac->bs, paddingSizeInBits, &padding)) {
+ return DRFLAC_AT_END;
+ }
+ }
+
+#ifndef DR_FLAC_NO_CRC
+ actualCRC16 = drflac__flush_crc16(&pFlac->bs);
+#endif
+ if (!drflac__read_uint16(&pFlac->bs, 16, &desiredCRC16)) {
+ return DRFLAC_AT_END;
+ }
+
+#ifndef DR_FLAC_NO_CRC
+ if (actualCRC16 != desiredCRC16) {
+ return DRFLAC_CRC_MISMATCH; /* CRC mismatch. */
+ }
+#endif
+
+ pFlac->currentFLACFrame.pcmFramesRemaining = pFlac->currentFLACFrame.header.blockSizeInPCMFrames;
+
+ return DRFLAC_SUCCESS;
+}
+
+static drflac_result drflac__seek_flac_frame(drflac* pFlac)
+{
+ int channelCount;
+ int i;
+ drflac_uint16 desiredCRC16;
+#ifndef DR_FLAC_NO_CRC
+ drflac_uint16 actualCRC16;
+#endif
+
+ channelCount = drflac__get_channel_count_from_channel_assignment(pFlac->currentFLACFrame.header.channelAssignment);
+ for (i = 0; i < channelCount; ++i) {
+ if (!drflac__seek_subframe(&pFlac->bs, &pFlac->currentFLACFrame, i)) {
+ return DRFLAC_ERROR;
+ }
+ }
+
+ /* Padding. */
+ if (!drflac__seek_bits(&pFlac->bs, DRFLAC_CACHE_L1_BITS_REMAINING(&pFlac->bs) & 7)) {
+ return DRFLAC_ERROR;
+ }
+
+ /* CRC. */
+#ifndef DR_FLAC_NO_CRC
+ actualCRC16 = drflac__flush_crc16(&pFlac->bs);
+#endif
+ if (!drflac__read_uint16(&pFlac->bs, 16, &desiredCRC16)) {
+ return DRFLAC_AT_END;
+ }
+
+#ifndef DR_FLAC_NO_CRC
+ if (actualCRC16 != desiredCRC16) {
+ return DRFLAC_CRC_MISMATCH; /* CRC mismatch. */
+ }
+#endif
+
+ return DRFLAC_SUCCESS;
+}
+
+static drflac_bool32 drflac__read_and_decode_next_flac_frame(drflac* pFlac)
+{
+ DRFLAC_ASSERT(pFlac != NULL);
+
+ for (;;) {
+ drflac_result result;
+
+ if (!drflac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) {
+ return DRFLAC_FALSE;
+ }
+
+ result = drflac__decode_flac_frame(pFlac);
+ if (result != DRFLAC_SUCCESS) {
+ if (result == DRFLAC_CRC_MISMATCH) {
+ continue; /* CRC mismatch. Skip to the next frame. */
+ } else {
+ return DRFLAC_FALSE;
+ }
+ }
+
+ return DRFLAC_TRUE;
+ }
+}
+
+static void drflac__get_pcm_frame_range_of_current_flac_frame(drflac* pFlac, drflac_uint64* pFirstPCMFrame, drflac_uint64* pLastPCMFrame)
+{
+ drflac_uint64 firstPCMFrame;
+ drflac_uint64 lastPCMFrame;
+
+ DRFLAC_ASSERT(pFlac != NULL);
+
+ firstPCMFrame = pFlac->currentFLACFrame.header.pcmFrameNumber;
+ if (firstPCMFrame == 0) {
+ firstPCMFrame = ((drflac_uint64)pFlac->currentFLACFrame.header.flacFrameNumber) * pFlac->maxBlockSizeInPCMFrames;
+ }
+
+ lastPCMFrame = firstPCMFrame + pFlac->currentFLACFrame.header.blockSizeInPCMFrames;
+ if (lastPCMFrame > 0) {
+ lastPCMFrame -= 1; /* Needs to be zero based. */
+ }
+
+ if (pFirstPCMFrame) {
+ *pFirstPCMFrame = firstPCMFrame;
+ }
+ if (pLastPCMFrame) {
+ *pLastPCMFrame = lastPCMFrame;
+ }
+}
+
+static drflac_bool32 drflac__seek_to_first_frame(drflac* pFlac)
+{
+ drflac_bool32 result;
+
+ DRFLAC_ASSERT(pFlac != NULL);
+
+ result = drflac__seek_to_byte(&pFlac->bs, pFlac->firstFLACFramePosInBytes);
+
+ DRFLAC_ZERO_MEMORY(&pFlac->currentFLACFrame, sizeof(pFlac->currentFLACFrame));
+ pFlac->currentPCMFrame = 0;
+
+ return result;
+}
+
+static DRFLAC_INLINE drflac_result drflac__seek_to_next_flac_frame(drflac* pFlac)
+{
+ /* This function should only ever be called while the decoder is sitting on the first byte past the FRAME_HEADER section. */
+ DRFLAC_ASSERT(pFlac != NULL);
+ return drflac__seek_flac_frame(pFlac);
+}
+
+
+static drflac_uint64 drflac__seek_forward_by_pcm_frames(drflac* pFlac, drflac_uint64 pcmFramesToSeek)
+{
+ drflac_uint64 pcmFramesRead = 0;
+ while (pcmFramesToSeek > 0) {
+ if (pFlac->currentFLACFrame.pcmFramesRemaining == 0) {
+ if (!drflac__read_and_decode_next_flac_frame(pFlac)) {
+ break; /* Couldn't read the next frame, so just break from the loop and return. */
+ }
+ } else {
+ if (pFlac->currentFLACFrame.pcmFramesRemaining > pcmFramesToSeek) {
+ pcmFramesRead += pcmFramesToSeek;
+ pFlac->currentFLACFrame.pcmFramesRemaining -= (drflac_uint32)pcmFramesToSeek; /* <-- Safe cast. Will always be < currentFrame.pcmFramesRemaining < 65536. */
+ pcmFramesToSeek = 0;
+ } else {
+ pcmFramesRead += pFlac->currentFLACFrame.pcmFramesRemaining;
+ pcmFramesToSeek -= pFlac->currentFLACFrame.pcmFramesRemaining;
+ pFlac->currentFLACFrame.pcmFramesRemaining = 0;
+ }
+ }
+ }
+
+ pFlac->currentPCMFrame += pcmFramesRead;
+ return pcmFramesRead;
+}
+
+
+static drflac_bool32 drflac__seek_to_pcm_frame__brute_force(drflac* pFlac, drflac_uint64 pcmFrameIndex)
+{
+ drflac_bool32 isMidFrame = DRFLAC_FALSE;
+ drflac_uint64 runningPCMFrameCount;
+
+ DRFLAC_ASSERT(pFlac != NULL);
+
+ /* If we are seeking forward we start from the current position. Otherwise we need to start all the way from the start of the file. */
+ if (pcmFrameIndex >= pFlac->currentPCMFrame) {
+ /* Seeking forward. Need to seek from the current position. */
+ runningPCMFrameCount = pFlac->currentPCMFrame;
+
+ /* The frame header for the first frame may not yet have been read. We need to do that if necessary. */
+ if (pFlac->currentPCMFrame == 0 && pFlac->currentFLACFrame.pcmFramesRemaining == 0) {
+ if (!drflac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) {
+ return DRFLAC_FALSE;
+ }
+ } else {
+ isMidFrame = DRFLAC_TRUE;
+ }
+ } else {
+ /* Seeking backwards. Need to seek from the start of the file. */
+ runningPCMFrameCount = 0;
+
+ /* Move back to the start. */
+ if (!drflac__seek_to_first_frame(pFlac)) {
+ return DRFLAC_FALSE;
+ }
+
+ /* Decode the first frame in preparation for sample-exact seeking below. */
+ if (!drflac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) {
+ return DRFLAC_FALSE;
+ }
+ }
+
+ /*
+ We need to as quickly as possible find the frame that contains the target sample. To do this, we iterate over each frame and inspect its
+ header. If based on the header we can determine that the frame contains the sample, we do a full decode of that frame.
+ */
+ for (;;) {
+ drflac_uint64 pcmFrameCountInThisFLACFrame;
+ drflac_uint64 firstPCMFrameInFLACFrame = 0;
+ drflac_uint64 lastPCMFrameInFLACFrame = 0;
+
+ drflac__get_pcm_frame_range_of_current_flac_frame(pFlac, &firstPCMFrameInFLACFrame, &lastPCMFrameInFLACFrame);
+
+ pcmFrameCountInThisFLACFrame = (lastPCMFrameInFLACFrame - firstPCMFrameInFLACFrame) + 1;
+ if (pcmFrameIndex < (runningPCMFrameCount + pcmFrameCountInThisFLACFrame)) {
+ /*
+ The sample should be in this frame. We need to fully decode it, however if it's an invalid frame (a CRC mismatch), we need to pretend
+ it never existed and keep iterating.
+ */
+ drflac_uint64 pcmFramesToDecode = pcmFrameIndex - runningPCMFrameCount;
+
+ if (!isMidFrame) {
+ drflac_result result = drflac__decode_flac_frame(pFlac);
+ if (result == DRFLAC_SUCCESS) {
+ /* The frame is valid. We just need to skip over some samples to ensure it's sample-exact. */
+ return drflac__seek_forward_by_pcm_frames(pFlac, pcmFramesToDecode) == pcmFramesToDecode; /* <-- If this fails, something bad has happened (it should never fail). */
+ } else {
+ if (result == DRFLAC_CRC_MISMATCH) {
+ goto next_iteration; /* CRC mismatch. Pretend this frame never existed. */
+ } else {
+ return DRFLAC_FALSE;
+ }
+ }
+ } else {
+ /* We started seeking mid-frame which means we need to skip the frame decoding part. */
+ return drflac__seek_forward_by_pcm_frames(pFlac, pcmFramesToDecode) == pcmFramesToDecode;
+ }
+ } else {
+ /*
+ It's not in this frame. We need to seek past the frame, but check if there was a CRC mismatch. If so, we pretend this
+ frame never existed and leave the running sample count untouched.
+ */
+ if (!isMidFrame) {
+ drflac_result result = drflac__seek_to_next_flac_frame(pFlac);
+ if (result == DRFLAC_SUCCESS) {
+ runningPCMFrameCount += pcmFrameCountInThisFLACFrame;
+ } else {
+ if (result == DRFLAC_CRC_MISMATCH) {
+ goto next_iteration; /* CRC mismatch. Pretend this frame never existed. */
+ } else {
+ return DRFLAC_FALSE;
+ }
+ }
+ } else {
+ /*
+ We started seeking mid-frame which means we need to seek by reading to the end of the frame instead of with
+ drflac__seek_to_next_flac_frame() which only works if the decoder is sitting on the byte just after the frame header.
+ */
+ runningPCMFrameCount += pFlac->currentFLACFrame.pcmFramesRemaining;
+ pFlac->currentFLACFrame.pcmFramesRemaining = 0;
+ isMidFrame = DRFLAC_FALSE;
+ }
+
+ /* If we are seeking to the end of the file and we've just hit it, we're done. */
+ if (pcmFrameIndex == pFlac->totalPCMFrameCount && runningPCMFrameCount == pFlac->totalPCMFrameCount) {
+ return DRFLAC_TRUE;
+ }
+ }
+
+ next_iteration:
+ /* Grab the next frame in preparation for the next iteration. */
+ if (!drflac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) {
+ return DRFLAC_FALSE;
+ }
+ }
+}
+
+
+#if !defined(DR_FLAC_NO_CRC)
+/*
+We use an average compression ratio to determine our approximate start location. FLAC files are generally about 50%-70% the size of their
+uncompressed counterparts so we'll use this as a basis. I'm going to split the middle and use a factor of 0.6 to determine the starting
+location.
+*/
+#define DRFLAC_BINARY_SEARCH_APPROX_COMPRESSION_RATIO 0.6f
+
+static drflac_bool32 drflac__seek_to_approximate_flac_frame_to_byte(drflac* pFlac, drflac_uint64 targetByte, drflac_uint64 rangeLo, drflac_uint64 rangeHi, drflac_uint64* pLastSuccessfulSeekOffset)
+{
+ DRFLAC_ASSERT(pFlac != NULL);
+ DRFLAC_ASSERT(pLastSuccessfulSeekOffset != NULL);
+ DRFLAC_ASSERT(targetByte >= rangeLo);
+ DRFLAC_ASSERT(targetByte <= rangeHi);
+
+ *pLastSuccessfulSeekOffset = pFlac->firstFLACFramePosInBytes;
+
+ for (;;) {
+ /* After rangeLo == rangeHi == targetByte fails, we need to break out. */
+ drflac_uint64 lastTargetByte = targetByte;
+
+ /* When seeking to a byte, failure probably means we've attempted to seek beyond the end of the stream. To counter this we just halve it each attempt. */
+ if (!drflac__seek_to_byte(&pFlac->bs, targetByte)) {
+ /* If we couldn't even seek to the first byte in the stream we have a problem. Just abandon the whole thing. */
+ if (targetByte == 0) {
+ drflac__seek_to_first_frame(pFlac); /* Try to recover. */
+ return DRFLAC_FALSE;
+ }
+
+ /* Halve the byte location and continue. */
+ targetByte = rangeLo + ((rangeHi - rangeLo)/2);
+ rangeHi = targetByte;
+ } else {
+ /* Getting here should mean that we have seeked to an appropriate byte. */
+
+ /* Clear the details of the FLAC frame so we don't misreport data. */
+ DRFLAC_ZERO_MEMORY(&pFlac->currentFLACFrame, sizeof(pFlac->currentFLACFrame));
+
+ /*
+ Now seek to the next FLAC frame. We need to decode the entire frame (not just the header) because it's possible for the header to incorrectly pass the
+ CRC check and return bad data. We need to decode the entire frame to be more certain. Although this seems unlikely, this has happened to me in testing
+ so it needs to stay this way for now.
+ */
+#if 1
+ if (!drflac__read_and_decode_next_flac_frame(pFlac)) {
+ /* Halve the byte location and continue. */
+ targetByte = rangeLo + ((rangeHi - rangeLo)/2);
+ rangeHi = targetByte;
+ } else {
+ break;
+ }
+#else
+ if (!drflac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) {
+ /* Halve the byte location and continue. */
+ targetByte = rangeLo + ((rangeHi - rangeLo)/2);
+ rangeHi = targetByte;
+ } else {
+ break;
+ }
+#endif
+ }
+
+ /* We already tried this byte and there are no more to try, break out. */
+ if(targetByte == lastTargetByte) {
+ return DRFLAC_FALSE;
+ }
+ }
+
+ /* The current PCM frame needs to be updated based on the frame we just seeked to. */
+ drflac__get_pcm_frame_range_of_current_flac_frame(pFlac, &pFlac->currentPCMFrame, NULL);
+
+ DRFLAC_ASSERT(targetByte <= rangeHi);
+
+ *pLastSuccessfulSeekOffset = targetByte;
+ return DRFLAC_TRUE;
+}
+
+static drflac_bool32 drflac__decode_flac_frame_and_seek_forward_by_pcm_frames(drflac* pFlac, drflac_uint64 offset)
+{
+ /* This section of code would be used if we were only decoding the FLAC frame header when calling drflac__seek_to_approximate_flac_frame_to_byte(). */
+#if 0
+ if (drflac__decode_flac_frame(pFlac) != DRFLAC_SUCCESS) {
+ /* We failed to decode this frame which may be due to it being corrupt. We'll just use the next valid FLAC frame. */
+ if (drflac__read_and_decode_next_flac_frame(pFlac) == DRFLAC_FALSE) {
+ return DRFLAC_FALSE;
+ }
+ }
+#endif
+
+ return drflac__seek_forward_by_pcm_frames(pFlac, offset) == offset;
+}
+
+
+static drflac_bool32 drflac__seek_to_pcm_frame__binary_search_internal(drflac* pFlac, drflac_uint64 pcmFrameIndex, drflac_uint64 byteRangeLo, drflac_uint64 byteRangeHi)
+{
+ /* This assumes pFlac->currentPCMFrame is sitting on byteRangeLo upon entry. */
+
+ drflac_uint64 targetByte;
+ drflac_uint64 pcmRangeLo = pFlac->totalPCMFrameCount;
+ drflac_uint64 pcmRangeHi = 0;
+ drflac_uint64 lastSuccessfulSeekOffset = (drflac_uint64)-1;
+ drflac_uint64 closestSeekOffsetBeforeTargetPCMFrame = byteRangeLo;
+ drflac_uint32 seekForwardThreshold = (pFlac->maxBlockSizeInPCMFrames != 0) ? pFlac->maxBlockSizeInPCMFrames*2 : 4096;
+
+ targetByte = byteRangeLo + (drflac_uint64)(((drflac_int64)((pcmFrameIndex - pFlac->currentPCMFrame) * pFlac->channels * pFlac->bitsPerSample)/8.0f) * DRFLAC_BINARY_SEARCH_APPROX_COMPRESSION_RATIO);
+ if (targetByte > byteRangeHi) {
+ targetByte = byteRangeHi;
+ }
+
+ for (;;) {
+ if (drflac__seek_to_approximate_flac_frame_to_byte(pFlac, targetByte, byteRangeLo, byteRangeHi, &lastSuccessfulSeekOffset)) {
+ /* We found a FLAC frame. We need to check if it contains the sample we're looking for. */
+ drflac_uint64 newPCMRangeLo;
+ drflac_uint64 newPCMRangeHi;
+ drflac__get_pcm_frame_range_of_current_flac_frame(pFlac, &newPCMRangeLo, &newPCMRangeHi);
+
+ /* If we selected the same frame, it means we should be pretty close. Just decode the rest. */
+ if (pcmRangeLo == newPCMRangeLo) {
+ if (!drflac__seek_to_approximate_flac_frame_to_byte(pFlac, closestSeekOffsetBeforeTargetPCMFrame, closestSeekOffsetBeforeTargetPCMFrame, byteRangeHi, &lastSuccessfulSeekOffset)) {
+ break; /* Failed to seek to closest frame. */
+ }
+
+ if (drflac__decode_flac_frame_and_seek_forward_by_pcm_frames(pFlac, pcmFrameIndex - pFlac->currentPCMFrame)) {
+ return DRFLAC_TRUE;
+ } else {
+ break; /* Failed to seek forward. */
+ }
+ }
+
+ pcmRangeLo = newPCMRangeLo;
+ pcmRangeHi = newPCMRangeHi;
+
+ if (pcmRangeLo <= pcmFrameIndex && pcmRangeHi >= pcmFrameIndex) {
+ /* The target PCM frame is in this FLAC frame. */
+ if (drflac__decode_flac_frame_and_seek_forward_by_pcm_frames(pFlac, pcmFrameIndex - pFlac->currentPCMFrame) ) {
+ return DRFLAC_TRUE;
+ } else {
+ break; /* Failed to seek to FLAC frame. */
+ }
+ } else {
+ const float approxCompressionRatio = (drflac_int64)(lastSuccessfulSeekOffset - pFlac->firstFLACFramePosInBytes) / ((drflac_int64)(pcmRangeLo * pFlac->channels * pFlac->bitsPerSample)/8.0f);
+
+ if (pcmRangeLo > pcmFrameIndex) {
+ /* We seeked too far forward. We need to move our target byte backward and try again. */
+ byteRangeHi = lastSuccessfulSeekOffset;
+ if (byteRangeLo > byteRangeHi) {
+ byteRangeLo = byteRangeHi;
+ }
+
+ targetByte = byteRangeLo + ((byteRangeHi - byteRangeLo) / 2);
+ if (targetByte < byteRangeLo) {
+ targetByte = byteRangeLo;
+ }
+ } else /*if (pcmRangeHi < pcmFrameIndex)*/ {
+ /* We didn't seek far enough. We need to move our target byte forward and try again. */
+
+ /* If we're close enough we can just seek forward. */
+ if ((pcmFrameIndex - pcmRangeLo) < seekForwardThreshold) {
+ if (drflac__decode_flac_frame_and_seek_forward_by_pcm_frames(pFlac, pcmFrameIndex - pFlac->currentPCMFrame)) {
+ return DRFLAC_TRUE;
+ } else {
+ break; /* Failed to seek to FLAC frame. */
+ }
+ } else {
+ byteRangeLo = lastSuccessfulSeekOffset;
+ if (byteRangeHi < byteRangeLo) {
+ byteRangeHi = byteRangeLo;
+ }
+
+ targetByte = lastSuccessfulSeekOffset + (drflac_uint64)(((drflac_int64)((pcmFrameIndex-pcmRangeLo) * pFlac->channels * pFlac->bitsPerSample)/8.0f) * approxCompressionRatio);
+ if (targetByte > byteRangeHi) {
+ targetByte = byteRangeHi;
+ }
+
+ if (closestSeekOffsetBeforeTargetPCMFrame < lastSuccessfulSeekOffset) {
+ closestSeekOffsetBeforeTargetPCMFrame = lastSuccessfulSeekOffset;
+ }
+ }
+ }
+ }
+ } else {
+ /* Getting here is really bad. We just recover as best we can, but moving to the first frame in the stream, and then abort. */
+ break;
+ }
+ }
+
+ drflac__seek_to_first_frame(pFlac); /* <-- Try to recover. */
+ return DRFLAC_FALSE;
+}
+
+static drflac_bool32 drflac__seek_to_pcm_frame__binary_search(drflac* pFlac, drflac_uint64 pcmFrameIndex)
+{
+ drflac_uint64 byteRangeLo;
+ drflac_uint64 byteRangeHi;
+ drflac_uint32 seekForwardThreshold = (pFlac->maxBlockSizeInPCMFrames != 0) ? pFlac->maxBlockSizeInPCMFrames*2 : 4096;
+
+ /* Our algorithm currently assumes the FLAC stream is currently sitting at the start. */
+ if (drflac__seek_to_first_frame(pFlac) == DRFLAC_FALSE) {
+ return DRFLAC_FALSE;
+ }
+
+ /* If we're close enough to the start, just move to the start and seek forward. */
+ if (pcmFrameIndex < seekForwardThreshold) {
+ return drflac__seek_forward_by_pcm_frames(pFlac, pcmFrameIndex) == pcmFrameIndex;
+ }
+
+ /*
+ Our starting byte range is the byte position of the first FLAC frame and the approximate end of the file as if it were completely uncompressed. This ensures
+ the entire file is included, even though most of the time it'll exceed the end of the actual stream. This is OK as the frame searching logic will handle it.
+ */
+ byteRangeLo = pFlac->firstFLACFramePosInBytes;
+ byteRangeHi = pFlac->firstFLACFramePosInBytes + (drflac_uint64)((drflac_int64)(pFlac->totalPCMFrameCount * pFlac->channels * pFlac->bitsPerSample)/8.0f);
+
+ return drflac__seek_to_pcm_frame__binary_search_internal(pFlac, pcmFrameIndex, byteRangeLo, byteRangeHi);
+}
+#endif /* !DR_FLAC_NO_CRC */
+
+static drflac_bool32 drflac__seek_to_pcm_frame__seek_table(drflac* pFlac, drflac_uint64 pcmFrameIndex)
+{
+ drflac_uint32 iClosestSeekpoint = 0;
+ drflac_bool32 isMidFrame = DRFLAC_FALSE;
+ drflac_uint64 runningPCMFrameCount;
+ drflac_uint32 iSeekpoint;
+
+
+ DRFLAC_ASSERT(pFlac != NULL);
+
+ if (pFlac->pSeekpoints == NULL || pFlac->seekpointCount == 0) {
+ return DRFLAC_FALSE;
+ }
+
+ /* Do not use the seektable if pcmFramIndex is not coverd by it. */
+ if (pFlac->pSeekpoints[0].firstPCMFrame > pcmFrameIndex) {
+ return DRFLAC_FALSE;
+ }
+
+ for (iSeekpoint = 0; iSeekpoint < pFlac->seekpointCount; ++iSeekpoint) {
+ if (pFlac->pSeekpoints[iSeekpoint].firstPCMFrame >= pcmFrameIndex) {
+ break;
+ }
+
+ iClosestSeekpoint = iSeekpoint;
+ }
+
+ /* There's been cases where the seek table contains only zeros. We need to do some basic validation on the closest seekpoint. */
+ if (pFlac->pSeekpoints[iClosestSeekpoint].pcmFrameCount == 0 || pFlac->pSeekpoints[iClosestSeekpoint].pcmFrameCount > pFlac->maxBlockSizeInPCMFrames) {
+ return DRFLAC_FALSE;
+ }
+ if (pFlac->pSeekpoints[iClosestSeekpoint].firstPCMFrame > pFlac->totalPCMFrameCount && pFlac->totalPCMFrameCount > 0) {
+ return DRFLAC_FALSE;
+ }
+
+#if !defined(DR_FLAC_NO_CRC)
+ /* At this point we should know the closest seek point. We can use a binary search for this. We need to know the total sample count for this. */
+ if (pFlac->totalPCMFrameCount > 0) {
+ drflac_uint64 byteRangeLo;
+ drflac_uint64 byteRangeHi;
+
+ byteRangeHi = pFlac->firstFLACFramePosInBytes + (drflac_uint64)((drflac_int64)(pFlac->totalPCMFrameCount * pFlac->channels * pFlac->bitsPerSample)/8.0f);
+ byteRangeLo = pFlac->firstFLACFramePosInBytes + pFlac->pSeekpoints[iClosestSeekpoint].flacFrameOffset;
+
+ /*
+ If our closest seek point is not the last one, we only need to search between it and the next one. The section below calculates an appropriate starting
+ value for byteRangeHi which will clamp it appropriately.
+
+ Note that the next seekpoint must have an offset greater than the closest seekpoint because otherwise our binary search algorithm will break down. There
+ have been cases where a seektable consists of seek points where every byte offset is set to 0 which causes problems. If this happens we need to abort.
+ */
+ if (iClosestSeekpoint < pFlac->seekpointCount-1) {
+ drflac_uint32 iNextSeekpoint = iClosestSeekpoint + 1;
+
+ /* Basic validation on the seekpoints to ensure they're usable. */
+ if (pFlac->pSeekpoints[iClosestSeekpoint].flacFrameOffset >= pFlac->pSeekpoints[iNextSeekpoint].flacFrameOffset || pFlac->pSeekpoints[iNextSeekpoint].pcmFrameCount == 0) {
+ return DRFLAC_FALSE; /* The next seekpoint doesn't look right. The seek table cannot be trusted from here. Abort. */
+ }
+
+ if (pFlac->pSeekpoints[iNextSeekpoint].firstPCMFrame != (((drflac_uint64)0xFFFFFFFF << 32) | 0xFFFFFFFF)) { /* Make sure it's not a placeholder seekpoint. */
+ byteRangeHi = pFlac->firstFLACFramePosInBytes + pFlac->pSeekpoints[iNextSeekpoint].flacFrameOffset - 1; /* byteRangeHi must be zero based. */
+ }
+ }
+
+ if (drflac__seek_to_byte(&pFlac->bs, pFlac->firstFLACFramePosInBytes + pFlac->pSeekpoints[iClosestSeekpoint].flacFrameOffset)) {
+ if (drflac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) {
+ drflac__get_pcm_frame_range_of_current_flac_frame(pFlac, &pFlac->currentPCMFrame, NULL);
+
+ if (drflac__seek_to_pcm_frame__binary_search_internal(pFlac, pcmFrameIndex, byteRangeLo, byteRangeHi)) {
+ return DRFLAC_TRUE;
+ }
+ }
+ }
+ }
+#endif /* !DR_FLAC_NO_CRC */
+
+ /* Getting here means we need to use a slower algorithm because the binary search method failed or cannot be used. */
+
+ /*
+ If we are seeking forward and the closest seekpoint is _before_ the current sample, we just seek forward from where we are. Otherwise we start seeking
+ from the seekpoint's first sample.
+ */
+ if (pcmFrameIndex >= pFlac->currentPCMFrame && pFlac->pSeekpoints[iClosestSeekpoint].firstPCMFrame <= pFlac->currentPCMFrame) {
+ /* Optimized case. Just seek forward from where we are. */
+ runningPCMFrameCount = pFlac->currentPCMFrame;
+
+ /* The frame header for the first frame may not yet have been read. We need to do that if necessary. */
+ if (pFlac->currentPCMFrame == 0 && pFlac->currentFLACFrame.pcmFramesRemaining == 0) {
+ if (!drflac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) {
+ return DRFLAC_FALSE;
+ }
+ } else {
+ isMidFrame = DRFLAC_TRUE;
+ }
+ } else {
+ /* Slower case. Seek to the start of the seekpoint and then seek forward from there. */
+ runningPCMFrameCount = pFlac->pSeekpoints[iClosestSeekpoint].firstPCMFrame;
+
+ if (!drflac__seek_to_byte(&pFlac->bs, pFlac->firstFLACFramePosInBytes + pFlac->pSeekpoints[iClosestSeekpoint].flacFrameOffset)) {
+ return DRFLAC_FALSE;
+ }
+
+ /* Grab the frame the seekpoint is sitting on in preparation for the sample-exact seeking below. */
+ if (!drflac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) {
+ return DRFLAC_FALSE;
+ }
+ }
+
+ for (;;) {
+ drflac_uint64 pcmFrameCountInThisFLACFrame;
+ drflac_uint64 firstPCMFrameInFLACFrame = 0;
+ drflac_uint64 lastPCMFrameInFLACFrame = 0;
+
+ drflac__get_pcm_frame_range_of_current_flac_frame(pFlac, &firstPCMFrameInFLACFrame, &lastPCMFrameInFLACFrame);
+
+ pcmFrameCountInThisFLACFrame = (lastPCMFrameInFLACFrame - firstPCMFrameInFLACFrame) + 1;
+ if (pcmFrameIndex < (runningPCMFrameCount + pcmFrameCountInThisFLACFrame)) {
+ /*
+ The sample should be in this frame. We need to fully decode it, but if it's an invalid frame (a CRC mismatch) we need to pretend
+ it never existed and keep iterating.
+ */
+ drflac_uint64 pcmFramesToDecode = pcmFrameIndex - runningPCMFrameCount;
+
+ if (!isMidFrame) {
+ drflac_result result = drflac__decode_flac_frame(pFlac);
+ if (result == DRFLAC_SUCCESS) {
+ /* The frame is valid. We just need to skip over some samples to ensure it's sample-exact. */
+ return drflac__seek_forward_by_pcm_frames(pFlac, pcmFramesToDecode) == pcmFramesToDecode; /* <-- If this fails, something bad has happened (it should never fail). */
+ } else {
+ if (result == DRFLAC_CRC_MISMATCH) {
+ goto next_iteration; /* CRC mismatch. Pretend this frame never existed. */
+ } else {
+ return DRFLAC_FALSE;
+ }
+ }
+ } else {
+ /* We started seeking mid-frame which means we need to skip the frame decoding part. */
+ return drflac__seek_forward_by_pcm_frames(pFlac, pcmFramesToDecode) == pcmFramesToDecode;
+ }
+ } else {
+ /*
+ It's not in this frame. We need to seek past the frame, but check if there was a CRC mismatch. If so, we pretend this
+ frame never existed and leave the running sample count untouched.
+ */
+ if (!isMidFrame) {
+ drflac_result result = drflac__seek_to_next_flac_frame(pFlac);
+ if (result == DRFLAC_SUCCESS) {
+ runningPCMFrameCount += pcmFrameCountInThisFLACFrame;
+ } else {
+ if (result == DRFLAC_CRC_MISMATCH) {
+ goto next_iteration; /* CRC mismatch. Pretend this frame never existed. */
+ } else {
+ return DRFLAC_FALSE;
+ }
+ }
+ } else {
+ /*
+ We started seeking mid-frame which means we need to seek by reading to the end of the frame instead of with
+ drflac__seek_to_next_flac_frame() which only works if the decoder is sitting on the byte just after the frame header.
+ */
+ runningPCMFrameCount += pFlac->currentFLACFrame.pcmFramesRemaining;
+ pFlac->currentFLACFrame.pcmFramesRemaining = 0;
+ isMidFrame = DRFLAC_FALSE;
+ }
+
+ /* If we are seeking to the end of the file and we've just hit it, we're done. */
+ if (pcmFrameIndex == pFlac->totalPCMFrameCount && runningPCMFrameCount == pFlac->totalPCMFrameCount) {
+ return DRFLAC_TRUE;
+ }
+ }
+
+ next_iteration:
+ /* Grab the next frame in preparation for the next iteration. */
+ if (!drflac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) {
+ return DRFLAC_FALSE;
+ }
+ }
+}
+
+
+#ifndef DR_FLAC_NO_OGG
+typedef struct
+{
+ drflac_uint8 capturePattern[4]; /* Should be "OggS" */
+ drflac_uint8 structureVersion; /* Always 0. */
+ drflac_uint8 headerType;
+ drflac_uint64 granulePosition;
+ drflac_uint32 serialNumber;
+ drflac_uint32 sequenceNumber;
+ drflac_uint32 checksum;
+ drflac_uint8 segmentCount;
+ drflac_uint8 segmentTable[255];
+} drflac_ogg_page_header;
+#endif
+
+typedef struct
+{
+ drflac_read_proc onRead;
+ drflac_seek_proc onSeek;
+ drflac_meta_proc onMeta;
+ drflac_container container;
+ void* pUserData;
+ void* pUserDataMD;
+ drflac_uint32 sampleRate;
+ drflac_uint8 channels;
+ drflac_uint8 bitsPerSample;
+ drflac_uint64 totalPCMFrameCount;
+ drflac_uint16 maxBlockSizeInPCMFrames;
+ drflac_uint64 runningFilePos;
+ drflac_bool32 hasStreamInfoBlock;
+ drflac_bool32 hasMetadataBlocks;
+ drflac_bs bs; /* <-- A bit streamer is required for loading data during initialization. */
+ drflac_frame_header firstFrameHeader; /* <-- The header of the first frame that was read during relaxed initalization. Only set if there is no STREAMINFO block. */
+
+#ifndef DR_FLAC_NO_OGG
+ drflac_uint32 oggSerial;
+ drflac_uint64 oggFirstBytePos;
+ drflac_ogg_page_header oggBosHeader;
+#endif
+} drflac_init_info;
+
+static DRFLAC_INLINE void drflac__decode_block_header(drflac_uint32 blockHeader, drflac_uint8* isLastBlock, drflac_uint8* blockType, drflac_uint32* blockSize)
+{
+ blockHeader = drflac__be2host_32(blockHeader);
+ *isLastBlock = (drflac_uint8)((blockHeader & 0x80000000UL) >> 31);
+ *blockType = (drflac_uint8)((blockHeader & 0x7F000000UL) >> 24);
+ *blockSize = (blockHeader & 0x00FFFFFFUL);
+}
+
+static DRFLAC_INLINE drflac_bool32 drflac__read_and_decode_block_header(drflac_read_proc onRead, void* pUserData, drflac_uint8* isLastBlock, drflac_uint8* blockType, drflac_uint32* blockSize)
+{
+ drflac_uint32 blockHeader;
+
+ *blockSize = 0;
+ if (onRead(pUserData, &blockHeader, 4) != 4) {
+ return DRFLAC_FALSE;
+ }
+
+ drflac__decode_block_header(blockHeader, isLastBlock, blockType, blockSize);
+ return DRFLAC_TRUE;
+}
+
+static drflac_bool32 drflac__read_streaminfo(drflac_read_proc onRead, void* pUserData, drflac_streaminfo* pStreamInfo)
+{
+ drflac_uint32 blockSizes;
+ drflac_uint64 frameSizes = 0;
+ drflac_uint64 importantProps;
+ drflac_uint8 md5[16];
+
+ /* min/max block size. */
+ if (onRead(pUserData, &blockSizes, 4) != 4) {
+ return DRFLAC_FALSE;
+ }
+
+ /* min/max frame size. */
+ if (onRead(pUserData, &frameSizes, 6) != 6) {
+ return DRFLAC_FALSE;
+ }
+
+ /* Sample rate, channels, bits per sample and total sample count. */
+ if (onRead(pUserData, &importantProps, 8) != 8) {
+ return DRFLAC_FALSE;
+ }
+
+ /* MD5 */
+ if (onRead(pUserData, md5, sizeof(md5)) != sizeof(md5)) {
+ return DRFLAC_FALSE;
+ }
+
+ blockSizes = drflac__be2host_32(blockSizes);
+ frameSizes = drflac__be2host_64(frameSizes);
+ importantProps = drflac__be2host_64(importantProps);
+
+ pStreamInfo->minBlockSizeInPCMFrames = (drflac_uint16)((blockSizes & 0xFFFF0000) >> 16);
+ pStreamInfo->maxBlockSizeInPCMFrames = (drflac_uint16) (blockSizes & 0x0000FFFF);
+ pStreamInfo->minFrameSizeInPCMFrames = (drflac_uint32)((frameSizes & (((drflac_uint64)0x00FFFFFF << 16) << 24)) >> 40);
+ pStreamInfo->maxFrameSizeInPCMFrames = (drflac_uint32)((frameSizes & (((drflac_uint64)0x00FFFFFF << 16) << 0)) >> 16);
+ pStreamInfo->sampleRate = (drflac_uint32)((importantProps & (((drflac_uint64)0x000FFFFF << 16) << 28)) >> 44);
+ pStreamInfo->channels = (drflac_uint8 )((importantProps & (((drflac_uint64)0x0000000E << 16) << 24)) >> 41) + 1;
+ pStreamInfo->bitsPerSample = (drflac_uint8 )((importantProps & (((drflac_uint64)0x0000001F << 16) << 20)) >> 36) + 1;
+ pStreamInfo->totalPCMFrameCount = ((importantProps & ((((drflac_uint64)0x0000000F << 16) << 16) | 0xFFFFFFFF)));
+ DRFLAC_COPY_MEMORY(pStreamInfo->md5, md5, sizeof(md5));
+
+ return DRFLAC_TRUE;
+}
+
+
+static void* drflac__malloc_default(size_t sz, void* pUserData)
+{
+ (void)pUserData;
+ return DRFLAC_MALLOC(sz);
+}
+
+static void* drflac__realloc_default(void* p, size_t sz, void* pUserData)
+{
+ (void)pUserData;
+ return DRFLAC_REALLOC(p, sz);
+}
+
+static void drflac__free_default(void* p, void* pUserData)
+{
+ (void)pUserData;
+ DRFLAC_FREE(p);
+}
+
+
+static void* drflac__malloc_from_callbacks(size_t sz, const drflac_allocation_callbacks* pAllocationCallbacks)
+{
+ if (pAllocationCallbacks == NULL) {
+ return NULL;
+ }
+
+ if (pAllocationCallbacks->onMalloc != NULL) {
+ return pAllocationCallbacks->onMalloc(sz, pAllocationCallbacks->pUserData);
+ }
+
+ /* Try using realloc(). */
+ if (pAllocationCallbacks->onRealloc != NULL) {
+ return pAllocationCallbacks->onRealloc(NULL, sz, pAllocationCallbacks->pUserData);
+ }
+
+ return NULL;
+}
+
+static void* drflac__realloc_from_callbacks(void* p, size_t szNew, size_t szOld, const drflac_allocation_callbacks* pAllocationCallbacks)
+{
+ if (pAllocationCallbacks == NULL) {
+ return NULL;
+ }
+
+ if (pAllocationCallbacks->onRealloc != NULL) {
+ return pAllocationCallbacks->onRealloc(p, szNew, pAllocationCallbacks->pUserData);
+ }
+
+ /* Try emulating realloc() in terms of malloc()/free(). */
+ if (pAllocationCallbacks->onMalloc != NULL && pAllocationCallbacks->onFree != NULL) {
+ void* p2;
+
+ p2 = pAllocationCallbacks->onMalloc(szNew, pAllocationCallbacks->pUserData);
+ if (p2 == NULL) {
+ return NULL;
+ }
+
+ if (p != NULL) {
+ DRFLAC_COPY_MEMORY(p2, p, szOld);
+ pAllocationCallbacks->onFree(p, pAllocationCallbacks->pUserData);
+ }
+
+ return p2;
+ }
+
+ return NULL;
+}
+
+static void drflac__free_from_callbacks(void* p, const drflac_allocation_callbacks* pAllocationCallbacks)
+{
+ if (p == NULL || pAllocationCallbacks == NULL) {
+ return;
+ }
+
+ if (pAllocationCallbacks->onFree != NULL) {
+ pAllocationCallbacks->onFree(p, pAllocationCallbacks->pUserData);
+ }
+}
+
+
+static drflac_bool32 drflac__read_and_decode_metadata(drflac_read_proc onRead, drflac_seek_proc onSeek, drflac_meta_proc onMeta, void* pUserData, void* pUserDataMD, drflac_uint64* pFirstFramePos, drflac_uint64* pSeektablePos, drflac_uint32* pSeekpointCount, drflac_allocation_callbacks* pAllocationCallbacks)
+{
+ /*
+ We want to keep track of the byte position in the stream of the seektable. At the time of calling this function we know that
+ we'll be sitting on byte 42.
+ */
+ drflac_uint64 runningFilePos = 42;
+ drflac_uint64 seektablePos = 0;
+ drflac_uint32 seektableSize = 0;
+
+ for (;;) {
+ drflac_metadata metadata;
+ drflac_uint8 isLastBlock = 0;
+ drflac_uint8 blockType = 0;
+ drflac_uint32 blockSize;
+ if (drflac__read_and_decode_block_header(onRead, pUserData, &isLastBlock, &blockType, &blockSize) == DRFLAC_FALSE) {
+ return DRFLAC_FALSE;
+ }
+ runningFilePos += 4;
+
+ metadata.type = blockType;
+ metadata.pRawData = NULL;
+ metadata.rawDataSize = 0;
+
+ switch (blockType)
+ {
+ case DRFLAC_METADATA_BLOCK_TYPE_APPLICATION:
+ {
+ if (blockSize < 4) {
+ return DRFLAC_FALSE;
+ }
+
+ if (onMeta) {
+ void* pRawData = drflac__malloc_from_callbacks(blockSize, pAllocationCallbacks);
+ if (pRawData == NULL) {
+ return DRFLAC_FALSE;
+ }
+
+ if (onRead(pUserData, pRawData, blockSize) != blockSize) {
+ drflac__free_from_callbacks(pRawData, pAllocationCallbacks);
+ return DRFLAC_FALSE;
+ }
+
+ metadata.pRawData = pRawData;
+ metadata.rawDataSize = blockSize;
+ metadata.data.application.id = drflac__be2host_32(*(drflac_uint32*)pRawData);
+ metadata.data.application.pData = (const void*)((drflac_uint8*)pRawData + sizeof(drflac_uint32));
+ metadata.data.application.dataSize = blockSize - sizeof(drflac_uint32);
+ onMeta(pUserDataMD, &metadata);
+
+ drflac__free_from_callbacks(pRawData, pAllocationCallbacks);
+ }
+ } break;
+
+ case DRFLAC_METADATA_BLOCK_TYPE_SEEKTABLE:
+ {
+ seektablePos = runningFilePos;
+ seektableSize = blockSize;
+
+ if (onMeta) {
+ drflac_uint32 seekpointCount;
+ drflac_uint32 iSeekpoint;
+ void* pRawData;
+
+ seekpointCount = blockSize/DRFLAC_SEEKPOINT_SIZE_IN_BYTES;
+
+ pRawData = drflac__malloc_from_callbacks(seekpointCount * sizeof(drflac_seekpoint), pAllocationCallbacks);
+ if (pRawData == NULL) {
+ return DRFLAC_FALSE;
+ }
+
+ /* We need to read seekpoint by seekpoint and do some processing. */
+ for (iSeekpoint = 0; iSeekpoint < seekpointCount; ++iSeekpoint) {
+ drflac_seekpoint* pSeekpoint = (drflac_seekpoint*)pRawData + iSeekpoint;
+
+ if (onRead(pUserData, pSeekpoint, DRFLAC_SEEKPOINT_SIZE_IN_BYTES) != DRFLAC_SEEKPOINT_SIZE_IN_BYTES) {
+ drflac__free_from_callbacks(pRawData, pAllocationCallbacks);
+ return DRFLAC_FALSE;
+ }
+
+ /* Endian swap. */
+ pSeekpoint->firstPCMFrame = drflac__be2host_64(pSeekpoint->firstPCMFrame);
+ pSeekpoint->flacFrameOffset = drflac__be2host_64(pSeekpoint->flacFrameOffset);
+ pSeekpoint->pcmFrameCount = drflac__be2host_16(pSeekpoint->pcmFrameCount);
+ }
+
+ metadata.pRawData = pRawData;
+ metadata.rawDataSize = blockSize;
+ metadata.data.seektable.seekpointCount = seekpointCount;
+ metadata.data.seektable.pSeekpoints = (const drflac_seekpoint*)pRawData;
+
+ onMeta(pUserDataMD, &metadata);
+
+ drflac__free_from_callbacks(pRawData, pAllocationCallbacks);
+ }
+ } break;
+
+ case DRFLAC_METADATA_BLOCK_TYPE_VORBIS_COMMENT:
+ {
+ if (blockSize < 8) {
+ return DRFLAC_FALSE;
+ }
+
+ if (onMeta) {
+ void* pRawData;
+ const char* pRunningData;
+ const char* pRunningDataEnd;
+ drflac_uint32 i;
+
+ pRawData = drflac__malloc_from_callbacks(blockSize, pAllocationCallbacks);
+ if (pRawData == NULL) {
+ return DRFLAC_FALSE;
+ }
+
+ if (onRead(pUserData, pRawData, blockSize) != blockSize) {
+ drflac__free_from_callbacks(pRawData, pAllocationCallbacks);
+ return DRFLAC_FALSE;
+ }
+
+ metadata.pRawData = pRawData;
+ metadata.rawDataSize = blockSize;
+
+ pRunningData = (const char*)pRawData;
+ pRunningDataEnd = (const char*)pRawData + blockSize;
+
+ metadata.data.vorbis_comment.vendorLength = drflac__le2host_32_ptr_unaligned(pRunningData); pRunningData += 4;
+
+ /* Need space for the rest of the block */
+ if ((pRunningDataEnd - pRunningData) - 4 < (drflac_int64)metadata.data.vorbis_comment.vendorLength) { /* <-- Note the order of operations to avoid overflow to a valid value */
+ drflac__free_from_callbacks(pRawData, pAllocationCallbacks);
+ return DRFLAC_FALSE;
+ }
+ metadata.data.vorbis_comment.vendor = pRunningData; pRunningData += metadata.data.vorbis_comment.vendorLength;
+ metadata.data.vorbis_comment.commentCount = drflac__le2host_32_ptr_unaligned(pRunningData); pRunningData += 4;
+
+ /* Need space for 'commentCount' comments after the block, which at minimum is a drflac_uint32 per comment */
+ if ((pRunningDataEnd - pRunningData) / sizeof(drflac_uint32) < metadata.data.vorbis_comment.commentCount) { /* <-- Note the order of operations to avoid overflow to a valid value */
+ drflac__free_from_callbacks(pRawData, pAllocationCallbacks);
+ return DRFLAC_FALSE;
+ }
+ metadata.data.vorbis_comment.pComments = pRunningData;
+
+ /* Check that the comments section is valid before passing it to the callback */
+ for (i = 0; i < metadata.data.vorbis_comment.commentCount; ++i) {
+ drflac_uint32 commentLength;
+
+ if (pRunningDataEnd - pRunningData < 4) {
+ drflac__free_from_callbacks(pRawData, pAllocationCallbacks);
+ return DRFLAC_FALSE;
+ }
+
+ commentLength = drflac__le2host_32_ptr_unaligned(pRunningData); pRunningData += 4;
+ if (pRunningDataEnd - pRunningData < (drflac_int64)commentLength) { /* <-- Note the order of operations to avoid overflow to a valid value */
+ drflac__free_from_callbacks(pRawData, pAllocationCallbacks);
+ return DRFLAC_FALSE;
+ }
+ pRunningData += commentLength;
+ }
+
+ onMeta(pUserDataMD, &metadata);
+
+ drflac__free_from_callbacks(pRawData, pAllocationCallbacks);
+ }
+ } break;
+
+ case DRFLAC_METADATA_BLOCK_TYPE_CUESHEET:
+ {
+ if (blockSize < 396) {
+ return DRFLAC_FALSE;
+ }
+
+ if (onMeta) {
+ void* pRawData;
+ const char* pRunningData;
+ const char* pRunningDataEnd;
+ size_t bufferSize;
+ drflac_uint8 iTrack;
+ drflac_uint8 iIndex;
+ void* pTrackData;
+
+ /*
+ This needs to be loaded in two passes. The first pass is used to calculate the size of the memory allocation
+ we need for storing the necessary data. The second pass will fill that buffer with usable data.
+ */
+ pRawData = drflac__malloc_from_callbacks(blockSize, pAllocationCallbacks);
+ if (pRawData == NULL) {
+ return DRFLAC_FALSE;
+ }
+
+ if (onRead(pUserData, pRawData, blockSize) != blockSize) {
+ drflac__free_from_callbacks(pRawData, pAllocationCallbacks);
+ return DRFLAC_FALSE;
+ }
+
+ metadata.pRawData = pRawData;
+ metadata.rawDataSize = blockSize;
+
+ pRunningData = (const char*)pRawData;
+ pRunningDataEnd = (const char*)pRawData + blockSize;
+
+ DRFLAC_COPY_MEMORY(metadata.data.cuesheet.catalog, pRunningData, 128); pRunningData += 128;
+ metadata.data.cuesheet.leadInSampleCount = drflac__be2host_64(*(const drflac_uint64*)pRunningData); pRunningData += 8;
+ metadata.data.cuesheet.isCD = (pRunningData[0] & 0x80) != 0; pRunningData += 259;
+ metadata.data.cuesheet.trackCount = pRunningData[0]; pRunningData += 1;
+ metadata.data.cuesheet.pTrackData = NULL; /* Will be filled later. */
+
+ /* Pass 1: Calculate the size of the buffer for the track data. */
+ {
+ const char* pRunningDataSaved = pRunningData; /* Will be restored at the end in preparation for the second pass. */
+
+ bufferSize = metadata.data.cuesheet.trackCount * DRFLAC_CUESHEET_TRACK_SIZE_IN_BYTES;
+
+ for (iTrack = 0; iTrack < metadata.data.cuesheet.trackCount; ++iTrack) {
+ drflac_uint8 indexCount;
+ drflac_uint32 indexPointSize;
+
+ if (pRunningDataEnd - pRunningData < DRFLAC_CUESHEET_TRACK_SIZE_IN_BYTES) {
+ drflac__free_from_callbacks(pRawData, pAllocationCallbacks);
+ return DRFLAC_FALSE;
+ }
+
+ /* Skip to the index point count */
+ pRunningData += 35;
+
+ indexCount = pRunningData[0];
+ pRunningData += 1;
+
+ bufferSize += indexCount * sizeof(drflac_cuesheet_track_index);
+
+ /* Quick validation check. */
+ indexPointSize = indexCount * DRFLAC_CUESHEET_TRACK_INDEX_SIZE_IN_BYTES;
+ if (pRunningDataEnd - pRunningData < (drflac_int64)indexPointSize) {
+ drflac__free_from_callbacks(pRawData, pAllocationCallbacks);
+ return DRFLAC_FALSE;
+ }
+
+ pRunningData += indexPointSize;
+ }
+
+ pRunningData = pRunningDataSaved;
+ }
+
+ /* Pass 2: Allocate a buffer and fill the data. Validation was done in the step above so can be skipped. */
+ {
+ char* pRunningTrackData;
+
+ pTrackData = drflac__malloc_from_callbacks(bufferSize, pAllocationCallbacks);
+ if (pTrackData == NULL) {
+ drflac__free_from_callbacks(pRawData, pAllocationCallbacks);
+ return DRFLAC_FALSE;
+ }
+
+ pRunningTrackData = (char*)pTrackData;
+
+ for (iTrack = 0; iTrack < metadata.data.cuesheet.trackCount; ++iTrack) {
+ drflac_uint8 indexCount;
+
+ DRFLAC_COPY_MEMORY(pRunningTrackData, pRunningData, DRFLAC_CUESHEET_TRACK_SIZE_IN_BYTES);
+ pRunningData += DRFLAC_CUESHEET_TRACK_SIZE_IN_BYTES-1; /* Skip forward, but not beyond the last byte in the CUESHEET_TRACK block which is the index count. */
+ pRunningTrackData += DRFLAC_CUESHEET_TRACK_SIZE_IN_BYTES-1;
+
+ /* Grab the index count for the next part. */
+ indexCount = pRunningData[0];
+ pRunningData += 1;
+ pRunningTrackData += 1;
+
+ /* Extract each track index. */
+ for (iIndex = 0; iIndex < indexCount; ++iIndex) {
+ drflac_cuesheet_track_index* pTrackIndex = (drflac_cuesheet_track_index*)pRunningTrackData;
+
+ DRFLAC_COPY_MEMORY(pRunningTrackData, pRunningData, DRFLAC_CUESHEET_TRACK_INDEX_SIZE_IN_BYTES);
+ pRunningData += DRFLAC_CUESHEET_TRACK_INDEX_SIZE_IN_BYTES;
+ pRunningTrackData += sizeof(drflac_cuesheet_track_index);
+
+ pTrackIndex->offset = drflac__be2host_64(pTrackIndex->offset);
+ }
+ }
+
+ metadata.data.cuesheet.pTrackData = pTrackData;
+ }
+
+ /* The original data is no longer needed. */
+ drflac__free_from_callbacks(pRawData, pAllocationCallbacks);
+ pRawData = NULL;
+
+ onMeta(pUserDataMD, &metadata);
+
+ drflac__free_from_callbacks(pTrackData, pAllocationCallbacks);
+ pTrackData = NULL;
+ }
+ } break;
+
+ case DRFLAC_METADATA_BLOCK_TYPE_PICTURE:
+ {
+ if (blockSize < 32) {
+ return DRFLAC_FALSE;
+ }
+
+ if (onMeta) {
+ void* pRawData;
+ const char* pRunningData;
+ const char* pRunningDataEnd;
+
+ pRawData = drflac__malloc_from_callbacks(blockSize, pAllocationCallbacks);
+ if (pRawData == NULL) {
+ return DRFLAC_FALSE;
+ }
+
+ if (onRead(pUserData, pRawData, blockSize) != blockSize) {
+ drflac__free_from_callbacks(pRawData, pAllocationCallbacks);
+ return DRFLAC_FALSE;
+ }
+
+ metadata.pRawData = pRawData;
+ metadata.rawDataSize = blockSize;
+
+ pRunningData = (const char*)pRawData;
+ pRunningDataEnd = (const char*)pRawData + blockSize;
+
+ metadata.data.picture.type = drflac__be2host_32_ptr_unaligned(pRunningData); pRunningData += 4;
+ metadata.data.picture.mimeLength = drflac__be2host_32_ptr_unaligned(pRunningData); pRunningData += 4;
+
+ /* Need space for the rest of the block */
+ if ((pRunningDataEnd - pRunningData) - 24 < (drflac_int64)metadata.data.picture.mimeLength) { /* <-- Note the order of operations to avoid overflow to a valid value */
+ drflac__free_from_callbacks(pRawData, pAllocationCallbacks);
+ return DRFLAC_FALSE;
+ }
+ metadata.data.picture.mime = pRunningData; pRunningData += metadata.data.picture.mimeLength;
+ metadata.data.picture.descriptionLength = drflac__be2host_32_ptr_unaligned(pRunningData); pRunningData += 4;
+
+ /* Need space for the rest of the block */
+ if ((pRunningDataEnd - pRunningData) - 20 < (drflac_int64)metadata.data.picture.descriptionLength) { /* <-- Note the order of operations to avoid overflow to a valid value */
+ drflac__free_from_callbacks(pRawData, pAllocationCallbacks);
+ return DRFLAC_FALSE;
+ }
+ metadata.data.picture.description = pRunningData; pRunningData += metadata.data.picture.descriptionLength;
+ metadata.data.picture.width = drflac__be2host_32_ptr_unaligned(pRunningData); pRunningData += 4;
+ metadata.data.picture.height = drflac__be2host_32_ptr_unaligned(pRunningData); pRunningData += 4;
+ metadata.data.picture.colorDepth = drflac__be2host_32_ptr_unaligned(pRunningData); pRunningData += 4;
+ metadata.data.picture.indexColorCount = drflac__be2host_32_ptr_unaligned(pRunningData); pRunningData += 4;
+ metadata.data.picture.pictureDataSize = drflac__be2host_32_ptr_unaligned(pRunningData); pRunningData += 4;
+ metadata.data.picture.pPictureData = (const drflac_uint8*)pRunningData;
+
+ /* Need space for the picture after the block */
+ if (pRunningDataEnd - pRunningData < (drflac_int64)metadata.data.picture.pictureDataSize) { /* <-- Note the order of operations to avoid overflow to a valid value */
+ drflac__free_from_callbacks(pRawData, pAllocationCallbacks);
+ return DRFLAC_FALSE;
+ }
+
+ onMeta(pUserDataMD, &metadata);
+
+ drflac__free_from_callbacks(pRawData, pAllocationCallbacks);
+ }
+ } break;
+
+ case DRFLAC_METADATA_BLOCK_TYPE_PADDING:
+ {
+ if (onMeta) {
+ metadata.data.padding.unused = 0;
+
+ /* Padding doesn't have anything meaningful in it, so just skip over it, but make sure the caller is aware of it by firing the callback. */
+ if (!onSeek(pUserData, blockSize, drflac_seek_origin_current)) {
+ isLastBlock = DRFLAC_TRUE; /* An error occurred while seeking. Attempt to recover by treating this as the last block which will in turn terminate the loop. */
+ } else {
+ onMeta(pUserDataMD, &metadata);
+ }
+ }
+ } break;
+
+ case DRFLAC_METADATA_BLOCK_TYPE_INVALID:
+ {
+ /* Invalid chunk. Just skip over this one. */
+ if (onMeta) {
+ if (!onSeek(pUserData, blockSize, drflac_seek_origin_current)) {
+ isLastBlock = DRFLAC_TRUE; /* An error occurred while seeking. Attempt to recover by treating this as the last block which will in turn terminate the loop. */
+ }
+ }
+ } break;
+
+ default:
+ {
+ /*
+ It's an unknown chunk, but not necessarily invalid. There's a chance more metadata blocks might be defined later on, so we
+ can at the very least report the chunk to the application and let it look at the raw data.
+ */
+ if (onMeta) {
+ void* pRawData = drflac__malloc_from_callbacks(blockSize, pAllocationCallbacks);
+ if (pRawData == NULL) {
+ return DRFLAC_FALSE;
+ }
+
+ if (onRead(pUserData, pRawData, blockSize) != blockSize) {
+ drflac__free_from_callbacks(pRawData, pAllocationCallbacks);
+ return DRFLAC_FALSE;
+ }
+
+ metadata.pRawData = pRawData;
+ metadata.rawDataSize = blockSize;
+ onMeta(pUserDataMD, &metadata);
+
+ drflac__free_from_callbacks(pRawData, pAllocationCallbacks);
+ }
+ } break;
+ }
+
+ /* If we're not handling metadata, just skip over the block. If we are, it will have been handled earlier in the switch statement above. */
+ if (onMeta == NULL && blockSize > 0) {
+ if (!onSeek(pUserData, blockSize, drflac_seek_origin_current)) {
+ isLastBlock = DRFLAC_TRUE;
+ }
+ }
+
+ runningFilePos += blockSize;
+ if (isLastBlock) {
+ break;
+ }
+ }
+
+ *pSeektablePos = seektablePos;
+ *pSeekpointCount = seektableSize / DRFLAC_SEEKPOINT_SIZE_IN_BYTES;
+ *pFirstFramePos = runningFilePos;
+
+ return DRFLAC_TRUE;
+}
+
+static drflac_bool32 drflac__init_private__native(drflac_init_info* pInit, drflac_read_proc onRead, drflac_seek_proc onSeek, drflac_meta_proc onMeta, void* pUserData, void* pUserDataMD, drflac_bool32 relaxed)
+{
+ /* Pre Condition: The bit stream should be sitting just past the 4-byte id header. */
+
+ drflac_uint8 isLastBlock;
+ drflac_uint8 blockType;
+ drflac_uint32 blockSize;
+
+ (void)onSeek;
+
+ pInit->container = drflac_container_native;
+
+ /* The first metadata block should be the STREAMINFO block. */
+ if (!drflac__read_and_decode_block_header(onRead, pUserData, &isLastBlock, &blockType, &blockSize)) {
+ return DRFLAC_FALSE;
+ }
+
+ if (blockType != DRFLAC_METADATA_BLOCK_TYPE_STREAMINFO || blockSize != 34) {
+ if (!relaxed) {
+ /* We're opening in strict mode and the first block is not the STREAMINFO block. Error. */
+ return DRFLAC_FALSE;
+ } else {
+ /*
+ Relaxed mode. To open from here we need to just find the first frame and set the sample rate, etc. to whatever is defined
+ for that frame.
+ */
+ pInit->hasStreamInfoBlock = DRFLAC_FALSE;
+ pInit->hasMetadataBlocks = DRFLAC_FALSE;
+
+ if (!drflac__read_next_flac_frame_header(&pInit->bs, 0, &pInit->firstFrameHeader)) {
+ return DRFLAC_FALSE; /* Couldn't find a frame. */
+ }
+
+ if (pInit->firstFrameHeader.bitsPerSample == 0) {
+ return DRFLAC_FALSE; /* Failed to initialize because the first frame depends on the STREAMINFO block, which does not exist. */
+ }
+
+ pInit->sampleRate = pInit->firstFrameHeader.sampleRate;
+ pInit->channels = drflac__get_channel_count_from_channel_assignment(pInit->firstFrameHeader.channelAssignment);
+ pInit->bitsPerSample = pInit->firstFrameHeader.bitsPerSample;
+ pInit->maxBlockSizeInPCMFrames = 65535; /* <-- See notes here: https://xiph.org/flac/format.html#metadata_block_streaminfo */
+ return DRFLAC_TRUE;
+ }
+ } else {
+ drflac_streaminfo streaminfo;
+ if (!drflac__read_streaminfo(onRead, pUserData, &streaminfo)) {
+ return DRFLAC_FALSE;
+ }
+
+ pInit->hasStreamInfoBlock = DRFLAC_TRUE;
+ pInit->sampleRate = streaminfo.sampleRate;
+ pInit->channels = streaminfo.channels;
+ pInit->bitsPerSample = streaminfo.bitsPerSample;
+ pInit->totalPCMFrameCount = streaminfo.totalPCMFrameCount;
+ pInit->maxBlockSizeInPCMFrames = streaminfo.maxBlockSizeInPCMFrames; /* Don't care about the min block size - only the max (used for determining the size of the memory allocation). */
+ pInit->hasMetadataBlocks = !isLastBlock;
+
+ if (onMeta) {
+ drflac_metadata metadata;
+ metadata.type = DRFLAC_METADATA_BLOCK_TYPE_STREAMINFO;
+ metadata.pRawData = NULL;
+ metadata.rawDataSize = 0;
+ metadata.data.streaminfo = streaminfo;
+ onMeta(pUserDataMD, &metadata);
+ }
+
+ return DRFLAC_TRUE;
+ }
+}
+
+#ifndef DR_FLAC_NO_OGG
+#define DRFLAC_OGG_MAX_PAGE_SIZE 65307
+#define DRFLAC_OGG_CAPTURE_PATTERN_CRC32 1605413199 /* CRC-32 of "OggS". */
+
+typedef enum
+{
+ drflac_ogg_recover_on_crc_mismatch,
+ drflac_ogg_fail_on_crc_mismatch
+} drflac_ogg_crc_mismatch_recovery;
+
+#ifndef DR_FLAC_NO_CRC
+static drflac_uint32 drflac__crc32_table[] = {
+ 0x00000000L, 0x04C11DB7L, 0x09823B6EL, 0x0D4326D9L,
+ 0x130476DCL, 0x17C56B6BL, 0x1A864DB2L, 0x1E475005L,
+ 0x2608EDB8L, 0x22C9F00FL, 0x2F8AD6D6L, 0x2B4BCB61L,
+ 0x350C9B64L, 0x31CD86D3L, 0x3C8EA00AL, 0x384FBDBDL,
+ 0x4C11DB70L, 0x48D0C6C7L, 0x4593E01EL, 0x4152FDA9L,
+ 0x5F15ADACL, 0x5BD4B01BL, 0x569796C2L, 0x52568B75L,
+ 0x6A1936C8L, 0x6ED82B7FL, 0x639B0DA6L, 0x675A1011L,
+ 0x791D4014L, 0x7DDC5DA3L, 0x709F7B7AL, 0x745E66CDL,
+ 0x9823B6E0L, 0x9CE2AB57L, 0x91A18D8EL, 0x95609039L,
+ 0x8B27C03CL, 0x8FE6DD8BL, 0x82A5FB52L, 0x8664E6E5L,
+ 0xBE2B5B58L, 0xBAEA46EFL, 0xB7A96036L, 0xB3687D81L,
+ 0xAD2F2D84L, 0xA9EE3033L, 0xA4AD16EAL, 0xA06C0B5DL,
+ 0xD4326D90L, 0xD0F37027L, 0xDDB056FEL, 0xD9714B49L,
+ 0xC7361B4CL, 0xC3F706FBL, 0xCEB42022L, 0xCA753D95L,
+ 0xF23A8028L, 0xF6FB9D9FL, 0xFBB8BB46L, 0xFF79A6F1L,
+ 0xE13EF6F4L, 0xE5FFEB43L, 0xE8BCCD9AL, 0xEC7DD02DL,
+ 0x34867077L, 0x30476DC0L, 0x3D044B19L, 0x39C556AEL,
+ 0x278206ABL, 0x23431B1CL, 0x2E003DC5L, 0x2AC12072L,
+ 0x128E9DCFL, 0x164F8078L, 0x1B0CA6A1L, 0x1FCDBB16L,
+ 0x018AEB13L, 0x054BF6A4L, 0x0808D07DL, 0x0CC9CDCAL,
+ 0x7897AB07L, 0x7C56B6B0L, 0x71159069L, 0x75D48DDEL,
+ 0x6B93DDDBL, 0x6F52C06CL, 0x6211E6B5L, 0x66D0FB02L,
+ 0x5E9F46BFL, 0x5A5E5B08L, 0x571D7DD1L, 0x53DC6066L,
+ 0x4D9B3063L, 0x495A2DD4L, 0x44190B0DL, 0x40D816BAL,
+ 0xACA5C697L, 0xA864DB20L, 0xA527FDF9L, 0xA1E6E04EL,
+ 0xBFA1B04BL, 0xBB60ADFCL, 0xB6238B25L, 0xB2E29692L,
+ 0x8AAD2B2FL, 0x8E6C3698L, 0x832F1041L, 0x87EE0DF6L,
+ 0x99A95DF3L, 0x9D684044L, 0x902B669DL, 0x94EA7B2AL,
+ 0xE0B41DE7L, 0xE4750050L, 0xE9362689L, 0xEDF73B3EL,
+ 0xF3B06B3BL, 0xF771768CL, 0xFA325055L, 0xFEF34DE2L,
+ 0xC6BCF05FL, 0xC27DEDE8L, 0xCF3ECB31L, 0xCBFFD686L,
+ 0xD5B88683L, 0xD1799B34L, 0xDC3ABDEDL, 0xD8FBA05AL,
+ 0x690CE0EEL, 0x6DCDFD59L, 0x608EDB80L, 0x644FC637L,
+ 0x7A089632L, 0x7EC98B85L, 0x738AAD5CL, 0x774BB0EBL,
+ 0x4F040D56L, 0x4BC510E1L, 0x46863638L, 0x42472B8FL,
+ 0x5C007B8AL, 0x58C1663DL, 0x558240E4L, 0x51435D53L,
+ 0x251D3B9EL, 0x21DC2629L, 0x2C9F00F0L, 0x285E1D47L,
+ 0x36194D42L, 0x32D850F5L, 0x3F9B762CL, 0x3B5A6B9BL,
+ 0x0315D626L, 0x07D4CB91L, 0x0A97ED48L, 0x0E56F0FFL,
+ 0x1011A0FAL, 0x14D0BD4DL, 0x19939B94L, 0x1D528623L,
+ 0xF12F560EL, 0xF5EE4BB9L, 0xF8AD6D60L, 0xFC6C70D7L,
+ 0xE22B20D2L, 0xE6EA3D65L, 0xEBA91BBCL, 0xEF68060BL,
+ 0xD727BBB6L, 0xD3E6A601L, 0xDEA580D8L, 0xDA649D6FL,
+ 0xC423CD6AL, 0xC0E2D0DDL, 0xCDA1F604L, 0xC960EBB3L,
+ 0xBD3E8D7EL, 0xB9FF90C9L, 0xB4BCB610L, 0xB07DABA7L,
+ 0xAE3AFBA2L, 0xAAFBE615L, 0xA7B8C0CCL, 0xA379DD7BL,
+ 0x9B3660C6L, 0x9FF77D71L, 0x92B45BA8L, 0x9675461FL,
+ 0x8832161AL, 0x8CF30BADL, 0x81B02D74L, 0x857130C3L,
+ 0x5D8A9099L, 0x594B8D2EL, 0x5408ABF7L, 0x50C9B640L,
+ 0x4E8EE645L, 0x4A4FFBF2L, 0x470CDD2BL, 0x43CDC09CL,
+ 0x7B827D21L, 0x7F436096L, 0x7200464FL, 0x76C15BF8L,
+ 0x68860BFDL, 0x6C47164AL, 0x61043093L, 0x65C52D24L,
+ 0x119B4BE9L, 0x155A565EL, 0x18197087L, 0x1CD86D30L,
+ 0x029F3D35L, 0x065E2082L, 0x0B1D065BL, 0x0FDC1BECL,
+ 0x3793A651L, 0x3352BBE6L, 0x3E119D3FL, 0x3AD08088L,
+ 0x2497D08DL, 0x2056CD3AL, 0x2D15EBE3L, 0x29D4F654L,
+ 0xC5A92679L, 0xC1683BCEL, 0xCC2B1D17L, 0xC8EA00A0L,
+ 0xD6AD50A5L, 0xD26C4D12L, 0xDF2F6BCBL, 0xDBEE767CL,
+ 0xE3A1CBC1L, 0xE760D676L, 0xEA23F0AFL, 0xEEE2ED18L,
+ 0xF0A5BD1DL, 0xF464A0AAL, 0xF9278673L, 0xFDE69BC4L,
+ 0x89B8FD09L, 0x8D79E0BEL, 0x803AC667L, 0x84FBDBD0L,
+ 0x9ABC8BD5L, 0x9E7D9662L, 0x933EB0BBL, 0x97FFAD0CL,
+ 0xAFB010B1L, 0xAB710D06L, 0xA6322BDFL, 0xA2F33668L,
+ 0xBCB4666DL, 0xB8757BDAL, 0xB5365D03L, 0xB1F740B4L
+};
+#endif
+
+static DRFLAC_INLINE drflac_uint32 drflac_crc32_byte(drflac_uint32 crc32, drflac_uint8 data)
+{
+#ifndef DR_FLAC_NO_CRC
+ return (crc32 << 8) ^ drflac__crc32_table[(drflac_uint8)((crc32 >> 24) & 0xFF) ^ data];
+#else
+ (void)data;
+ return crc32;
+#endif
+}
+
+#if 0
+static DRFLAC_INLINE drflac_uint32 drflac_crc32_uint32(drflac_uint32 crc32, drflac_uint32 data)
+{
+ crc32 = drflac_crc32_byte(crc32, (drflac_uint8)((data >> 24) & 0xFF));
+ crc32 = drflac_crc32_byte(crc32, (drflac_uint8)((data >> 16) & 0xFF));
+ crc32 = drflac_crc32_byte(crc32, (drflac_uint8)((data >> 8) & 0xFF));
+ crc32 = drflac_crc32_byte(crc32, (drflac_uint8)((data >> 0) & 0xFF));
+ return crc32;
+}
+
+static DRFLAC_INLINE drflac_uint32 drflac_crc32_uint64(drflac_uint32 crc32, drflac_uint64 data)
+{
+ crc32 = drflac_crc32_uint32(crc32, (drflac_uint32)((data >> 32) & 0xFFFFFFFF));
+ crc32 = drflac_crc32_uint32(crc32, (drflac_uint32)((data >> 0) & 0xFFFFFFFF));
+ return crc32;
+}
+#endif
+
+static DRFLAC_INLINE drflac_uint32 drflac_crc32_buffer(drflac_uint32 crc32, drflac_uint8* pData, drflac_uint32 dataSize)
+{
+ /* This can be optimized. */
+ drflac_uint32 i;
+ for (i = 0; i < dataSize; ++i) {
+ crc32 = drflac_crc32_byte(crc32, pData[i]);
+ }
+ return crc32;
+}
+
+
+static DRFLAC_INLINE drflac_bool32 drflac_ogg__is_capture_pattern(drflac_uint8 pattern[4])
+{
+ return pattern[0] == 'O' && pattern[1] == 'g' && pattern[2] == 'g' && pattern[3] == 'S';
+}
+
+static DRFLAC_INLINE drflac_uint32 drflac_ogg__get_page_header_size(drflac_ogg_page_header* pHeader)
+{
+ return 27 + pHeader->segmentCount;
+}
+
+static DRFLAC_INLINE drflac_uint32 drflac_ogg__get_page_body_size(drflac_ogg_page_header* pHeader)
+{
+ drflac_uint32 pageBodySize = 0;
+ int i;
+
+ for (i = 0; i < pHeader->segmentCount; ++i) {
+ pageBodySize += pHeader->segmentTable[i];
+ }
+
+ return pageBodySize;
+}
+
+static drflac_result drflac_ogg__read_page_header_after_capture_pattern(drflac_read_proc onRead, void* pUserData, drflac_ogg_page_header* pHeader, drflac_uint32* pBytesRead, drflac_uint32* pCRC32)
+{
+ drflac_uint8 data[23];
+ drflac_uint32 i;
+
+ DRFLAC_ASSERT(*pCRC32 == DRFLAC_OGG_CAPTURE_PATTERN_CRC32);
+
+ if (onRead(pUserData, data, 23) != 23) {
+ return DRFLAC_AT_END;
+ }
+ *pBytesRead += 23;
+
+ /*
+ It's not actually used, but set the capture pattern to 'OggS' for completeness. Not doing this will cause static analysers to complain about
+ us trying to access uninitialized data. We could alternatively just comment out this member of the drflac_ogg_page_header structure, but I
+ like to have it map to the structure of the underlying data.
+ */
+ pHeader->capturePattern[0] = 'O';
+ pHeader->capturePattern[1] = 'g';
+ pHeader->capturePattern[2] = 'g';
+ pHeader->capturePattern[3] = 'S';
+
+ pHeader->structureVersion = data[0];
+ pHeader->headerType = data[1];
+ DRFLAC_COPY_MEMORY(&pHeader->granulePosition, &data[ 2], 8);
+ DRFLAC_COPY_MEMORY(&pHeader->serialNumber, &data[10], 4);
+ DRFLAC_COPY_MEMORY(&pHeader->sequenceNumber, &data[14], 4);
+ DRFLAC_COPY_MEMORY(&pHeader->checksum, &data[18], 4);
+ pHeader->segmentCount = data[22];
+
+ /* Calculate the CRC. Note that for the calculation the checksum part of the page needs to be set to 0. */
+ data[18] = 0;
+ data[19] = 0;
+ data[20] = 0;
+ data[21] = 0;
+
+ for (i = 0; i < 23; ++i) {
+ *pCRC32 = drflac_crc32_byte(*pCRC32, data[i]);
+ }
+
+
+ if (onRead(pUserData, pHeader->segmentTable, pHeader->segmentCount) != pHeader->segmentCount) {
+ return DRFLAC_AT_END;
+ }
+ *pBytesRead += pHeader->segmentCount;
+
+ for (i = 0; i < pHeader->segmentCount; ++i) {
+ *pCRC32 = drflac_crc32_byte(*pCRC32, pHeader->segmentTable[i]);
+ }
+
+ return DRFLAC_SUCCESS;
+}
+
+static drflac_result drflac_ogg__read_page_header(drflac_read_proc onRead, void* pUserData, drflac_ogg_page_header* pHeader, drflac_uint32* pBytesRead, drflac_uint32* pCRC32)
+{
+ drflac_uint8 id[4];
+
+ *pBytesRead = 0;
+
+ if (onRead(pUserData, id, 4) != 4) {
+ return DRFLAC_AT_END;
+ }
+ *pBytesRead += 4;
+
+ /* We need to read byte-by-byte until we find the OggS capture pattern. */
+ for (;;) {
+ if (drflac_ogg__is_capture_pattern(id)) {
+ drflac_result result;
+
+ *pCRC32 = DRFLAC_OGG_CAPTURE_PATTERN_CRC32;
+
+ result = drflac_ogg__read_page_header_after_capture_pattern(onRead, pUserData, pHeader, pBytesRead, pCRC32);
+ if (result == DRFLAC_SUCCESS) {
+ return DRFLAC_SUCCESS;
+ } else {
+ if (result == DRFLAC_CRC_MISMATCH) {
+ continue;
+ } else {
+ return result;
+ }
+ }
+ } else {
+ /* The first 4 bytes did not equal the capture pattern. Read the next byte and try again. */
+ id[0] = id[1];
+ id[1] = id[2];
+ id[2] = id[3];
+ if (onRead(pUserData, &id[3], 1) != 1) {
+ return DRFLAC_AT_END;
+ }
+ *pBytesRead += 1;
+ }
+ }
+}
+
+
+/*
+The main part of the Ogg encapsulation is the conversion from the physical Ogg bitstream to the native FLAC bitstream. It works
+in three general stages: Ogg Physical Bitstream -> Ogg/FLAC Logical Bitstream -> FLAC Native Bitstream. dr_flac is designed
+in such a way that the core sections assume everything is delivered in native format. Therefore, for each encapsulation type
+dr_flac is supporting there needs to be a layer sitting on top of the onRead and onSeek callbacks that ensures the bits read from
+the physical Ogg bitstream are converted and delivered in native FLAC format.
+*/
+typedef struct
+{
+ drflac_read_proc onRead; /* The original onRead callback from drflac_open() and family. */
+ drflac_seek_proc onSeek; /* The original onSeek callback from drflac_open() and family. */
+ void* pUserData; /* The user data passed on onRead and onSeek. This is the user data that was passed on drflac_open() and family. */
+ drflac_uint64 currentBytePos; /* The position of the byte we are sitting on in the physical byte stream. Used for efficient seeking. */
+ drflac_uint64 firstBytePos; /* The position of the first byte in the physical bitstream. Points to the start of the "OggS" identifier of the FLAC bos page. */
+ drflac_uint32 serialNumber; /* The serial number of the FLAC audio pages. This is determined by the initial header page that was read during initialization. */
+ drflac_ogg_page_header bosPageHeader; /* Used for seeking. */
+ drflac_ogg_page_header currentPageHeader;
+ drflac_uint32 bytesRemainingInPage;
+ drflac_uint32 pageDataSize;
+ drflac_uint8 pageData[DRFLAC_OGG_MAX_PAGE_SIZE];
+} drflac_oggbs; /* oggbs = Ogg Bitstream */
+
+static size_t drflac_oggbs__read_physical(drflac_oggbs* oggbs, void* bufferOut, size_t bytesToRead)
+{
+ size_t bytesActuallyRead = oggbs->onRead(oggbs->pUserData, bufferOut, bytesToRead);
+ oggbs->currentBytePos += bytesActuallyRead;
+
+ return bytesActuallyRead;
+}
+
+static drflac_bool32 drflac_oggbs__seek_physical(drflac_oggbs* oggbs, drflac_uint64 offset, drflac_seek_origin origin)
+{
+ if (origin == drflac_seek_origin_start) {
+ if (offset <= 0x7FFFFFFF) {
+ if (!oggbs->onSeek(oggbs->pUserData, (int)offset, drflac_seek_origin_start)) {
+ return DRFLAC_FALSE;
+ }
+ oggbs->currentBytePos = offset;
+
+ return DRFLAC_TRUE;
+ } else {
+ if (!oggbs->onSeek(oggbs->pUserData, 0x7FFFFFFF, drflac_seek_origin_start)) {
+ return DRFLAC_FALSE;
+ }
+ oggbs->currentBytePos = offset;
+
+ return drflac_oggbs__seek_physical(oggbs, offset - 0x7FFFFFFF, drflac_seek_origin_current);
+ }
+ } else {
+ while (offset > 0x7FFFFFFF) {
+ if (!oggbs->onSeek(oggbs->pUserData, 0x7FFFFFFF, drflac_seek_origin_current)) {
+ return DRFLAC_FALSE;
+ }
+ oggbs->currentBytePos += 0x7FFFFFFF;
+ offset -= 0x7FFFFFFF;
+ }
+
+ if (!oggbs->onSeek(oggbs->pUserData, (int)offset, drflac_seek_origin_current)) { /* <-- Safe cast thanks to the loop above. */
+ return DRFLAC_FALSE;
+ }
+ oggbs->currentBytePos += offset;
+
+ return DRFLAC_TRUE;
+ }
+}
+
+static drflac_bool32 drflac_oggbs__goto_next_page(drflac_oggbs* oggbs, drflac_ogg_crc_mismatch_recovery recoveryMethod)
+{
+ drflac_ogg_page_header header;
+ for (;;) {
+ drflac_uint32 crc32 = 0;
+ drflac_uint32 bytesRead;
+ drflac_uint32 pageBodySize;
+#ifndef DR_FLAC_NO_CRC
+ drflac_uint32 actualCRC32;
+#endif
+
+ if (drflac_ogg__read_page_header(oggbs->onRead, oggbs->pUserData, &header, &bytesRead, &crc32) != DRFLAC_SUCCESS) {
+ return DRFLAC_FALSE;
+ }
+ oggbs->currentBytePos += bytesRead;
+
+ pageBodySize = drflac_ogg__get_page_body_size(&header);
+ if (pageBodySize > DRFLAC_OGG_MAX_PAGE_SIZE) {
+ continue; /* Invalid page size. Assume it's corrupted and just move to the next page. */
+ }
+
+ if (header.serialNumber != oggbs->serialNumber) {
+ /* It's not a FLAC page. Skip it. */
+ if (pageBodySize > 0 && !drflac_oggbs__seek_physical(oggbs, pageBodySize, drflac_seek_origin_current)) {
+ return DRFLAC_FALSE;
+ }
+ continue;
+ }
+
+
+ /* We need to read the entire page and then do a CRC check on it. If there's a CRC mismatch we need to skip this page. */
+ if (drflac_oggbs__read_physical(oggbs, oggbs->pageData, pageBodySize) != pageBodySize) {
+ return DRFLAC_FALSE;
+ }
+ oggbs->pageDataSize = pageBodySize;
+
+#ifndef DR_FLAC_NO_CRC
+ actualCRC32 = drflac_crc32_buffer(crc32, oggbs->pageData, oggbs->pageDataSize);
+ if (actualCRC32 != header.checksum) {
+ if (recoveryMethod == drflac_ogg_recover_on_crc_mismatch) {
+ continue; /* CRC mismatch. Skip this page. */
+ } else {
+ /*
+ Even though we are failing on a CRC mismatch, we still want our stream to be in a good state. Therefore we
+ go to the next valid page to ensure we're in a good state, but return false to let the caller know that the
+ seek did not fully complete.
+ */
+ drflac_oggbs__goto_next_page(oggbs, drflac_ogg_recover_on_crc_mismatch);
+ return DRFLAC_FALSE;
+ }
+ }
+#else
+ (void)recoveryMethod; /* <-- Silence a warning. */
+#endif
+
+ oggbs->currentPageHeader = header;
+ oggbs->bytesRemainingInPage = pageBodySize;
+ return DRFLAC_TRUE;
+ }
+}
+
+/* Function below is unused at the moment, but I might be re-adding it later. */
+#if 0
+static drflac_uint8 drflac_oggbs__get_current_segment_index(drflac_oggbs* oggbs, drflac_uint8* pBytesRemainingInSeg)
+{
+ drflac_uint32 bytesConsumedInPage = drflac_ogg__get_page_body_size(&oggbs->currentPageHeader) - oggbs->bytesRemainingInPage;
+ drflac_uint8 iSeg = 0;
+ drflac_uint32 iByte = 0;
+ while (iByte < bytesConsumedInPage) {
+ drflac_uint8 segmentSize = oggbs->currentPageHeader.segmentTable[iSeg];
+ if (iByte + segmentSize > bytesConsumedInPage) {
+ break;
+ } else {
+ iSeg += 1;
+ iByte += segmentSize;
+ }
+ }
+
+ *pBytesRemainingInSeg = oggbs->currentPageHeader.segmentTable[iSeg] - (drflac_uint8)(bytesConsumedInPage - iByte);
+ return iSeg;
+}
+
+static drflac_bool32 drflac_oggbs__seek_to_next_packet(drflac_oggbs* oggbs)
+{
+ /* The current packet ends when we get to the segment with a lacing value of < 255 which is not at the end of a page. */
+ for (;;) {
+ drflac_bool32 atEndOfPage = DRFLAC_FALSE;
+
+ drflac_uint8 bytesRemainingInSeg;
+ drflac_uint8 iFirstSeg = drflac_oggbs__get_current_segment_index(oggbs, &bytesRemainingInSeg);
+
+ drflac_uint32 bytesToEndOfPacketOrPage = bytesRemainingInSeg;
+ for (drflac_uint8 iSeg = iFirstSeg; iSeg < oggbs->currentPageHeader.segmentCount; ++iSeg) {
+ drflac_uint8 segmentSize = oggbs->currentPageHeader.segmentTable[iSeg];
+ if (segmentSize < 255) {
+ if (iSeg == oggbs->currentPageHeader.segmentCount-1) {
+ atEndOfPage = DRFLAC_TRUE;
+ }
+
+ break;
+ }
+
+ bytesToEndOfPacketOrPage += segmentSize;
+ }
+
+ /*
+ At this point we will have found either the packet or the end of the page. If were at the end of the page we'll
+ want to load the next page and keep searching for the end of the packet.
+ */
+ drflac_oggbs__seek_physical(oggbs, bytesToEndOfPacketOrPage, drflac_seek_origin_current);
+ oggbs->bytesRemainingInPage -= bytesToEndOfPacketOrPage;
+
+ if (atEndOfPage) {
+ /*
+ We're potentially at the next packet, but we need to check the next page first to be sure because the packet may
+ straddle pages.
+ */
+ if (!drflac_oggbs__goto_next_page(oggbs)) {
+ return DRFLAC_FALSE;
+ }
+
+ /* If it's a fresh packet it most likely means we're at the next packet. */
+ if ((oggbs->currentPageHeader.headerType & 0x01) == 0) {
+ return DRFLAC_TRUE;
+ }
+ } else {
+ /* We're at the next packet. */
+ return DRFLAC_TRUE;
+ }
+ }
+}
+
+static drflac_bool32 drflac_oggbs__seek_to_next_frame(drflac_oggbs* oggbs)
+{
+ /* The bitstream should be sitting on the first byte just after the header of the frame. */
+
+ /* What we're actually doing here is seeking to the start of the next packet. */
+ return drflac_oggbs__seek_to_next_packet(oggbs);
+}
+#endif
+
+static size_t drflac__on_read_ogg(void* pUserData, void* bufferOut, size_t bytesToRead)
+{
+ drflac_oggbs* oggbs = (drflac_oggbs*)pUserData;
+ drflac_uint8* pRunningBufferOut = (drflac_uint8*)bufferOut;
+ size_t bytesRead = 0;
+
+ DRFLAC_ASSERT(oggbs != NULL);
+ DRFLAC_ASSERT(pRunningBufferOut != NULL);
+
+ /* Reading is done page-by-page. If we've run out of bytes in the page we need to move to the next one. */
+ while (bytesRead < bytesToRead) {
+ size_t bytesRemainingToRead = bytesToRead - bytesRead;
+
+ if (oggbs->bytesRemainingInPage >= bytesRemainingToRead) {
+ DRFLAC_COPY_MEMORY(pRunningBufferOut, oggbs->pageData + (oggbs->pageDataSize - oggbs->bytesRemainingInPage), bytesRemainingToRead);
+ bytesRead += bytesRemainingToRead;
+ oggbs->bytesRemainingInPage -= (drflac_uint32)bytesRemainingToRead;
+ break;
+ }
+
+ /* If we get here it means some of the requested data is contained in the next pages. */
+ if (oggbs->bytesRemainingInPage > 0) {
+ DRFLAC_COPY_MEMORY(pRunningBufferOut, oggbs->pageData + (oggbs->pageDataSize - oggbs->bytesRemainingInPage), oggbs->bytesRemainingInPage);
+ bytesRead += oggbs->bytesRemainingInPage;
+ pRunningBufferOut += oggbs->bytesRemainingInPage;
+ oggbs->bytesRemainingInPage = 0;
+ }
+
+ DRFLAC_ASSERT(bytesRemainingToRead > 0);
+ if (!drflac_oggbs__goto_next_page(oggbs, drflac_ogg_recover_on_crc_mismatch)) {
+ break; /* Failed to go to the next page. Might have simply hit the end of the stream. */
+ }
+ }
+
+ return bytesRead;
+}
+
+static drflac_bool32 drflac__on_seek_ogg(void* pUserData, int offset, drflac_seek_origin origin)
+{
+ drflac_oggbs* oggbs = (drflac_oggbs*)pUserData;
+ int bytesSeeked = 0;
+
+ DRFLAC_ASSERT(oggbs != NULL);
+ DRFLAC_ASSERT(offset >= 0); /* <-- Never seek backwards. */
+
+ /* Seeking is always forward which makes things a lot simpler. */
+ if (origin == drflac_seek_origin_start) {
+ if (!drflac_oggbs__seek_physical(oggbs, (int)oggbs->firstBytePos, drflac_seek_origin_start)) {
+ return DRFLAC_FALSE;
+ }
+
+ if (!drflac_oggbs__goto_next_page(oggbs, drflac_ogg_fail_on_crc_mismatch)) {
+ return DRFLAC_FALSE;
+ }
+
+ return drflac__on_seek_ogg(pUserData, offset, drflac_seek_origin_current);
+ }
+
+ DRFLAC_ASSERT(origin == drflac_seek_origin_current);
+
+ while (bytesSeeked < offset) {
+ int bytesRemainingToSeek = offset - bytesSeeked;
+ DRFLAC_ASSERT(bytesRemainingToSeek >= 0);
+
+ if (oggbs->bytesRemainingInPage >= (size_t)bytesRemainingToSeek) {
+ bytesSeeked += bytesRemainingToSeek;
+ (void)bytesSeeked; /* <-- Silence a dead store warning emitted by Clang Static Analyzer. */
+ oggbs->bytesRemainingInPage -= bytesRemainingToSeek;
+ break;
+ }
+
+ /* If we get here it means some of the requested data is contained in the next pages. */
+ if (oggbs->bytesRemainingInPage > 0) {
+ bytesSeeked += (int)oggbs->bytesRemainingInPage;
+ oggbs->bytesRemainingInPage = 0;
+ }
+
+ DRFLAC_ASSERT(bytesRemainingToSeek > 0);
+ if (!drflac_oggbs__goto_next_page(oggbs, drflac_ogg_fail_on_crc_mismatch)) {
+ /* Failed to go to the next page. We either hit the end of the stream or had a CRC mismatch. */
+ return DRFLAC_FALSE;
+ }
+ }
+
+ return DRFLAC_TRUE;
+}
+
+
+static drflac_bool32 drflac_ogg__seek_to_pcm_frame(drflac* pFlac, drflac_uint64 pcmFrameIndex)
+{
+ drflac_oggbs* oggbs = (drflac_oggbs*)pFlac->_oggbs;
+ drflac_uint64 originalBytePos;
+ drflac_uint64 runningGranulePosition;
+ drflac_uint64 runningFrameBytePos;
+ drflac_uint64 runningPCMFrameCount;
+
+ DRFLAC_ASSERT(oggbs != NULL);
+
+ originalBytePos = oggbs->currentBytePos; /* For recovery. Points to the OggS identifier. */
+
+ /* First seek to the first frame. */
+ if (!drflac__seek_to_byte(&pFlac->bs, pFlac->firstFLACFramePosInBytes)) {
+ return DRFLAC_FALSE;
+ }
+ oggbs->bytesRemainingInPage = 0;
+
+ runningGranulePosition = 0;
+ for (;;) {
+ if (!drflac_oggbs__goto_next_page(oggbs, drflac_ogg_recover_on_crc_mismatch)) {
+ drflac_oggbs__seek_physical(oggbs, originalBytePos, drflac_seek_origin_start);
+ return DRFLAC_FALSE; /* Never did find that sample... */
+ }
+
+ runningFrameBytePos = oggbs->currentBytePos - drflac_ogg__get_page_header_size(&oggbs->currentPageHeader) - oggbs->pageDataSize;
+ if (oggbs->currentPageHeader.granulePosition >= pcmFrameIndex) {
+ break; /* The sample is somewhere in the previous page. */
+ }
+
+ /*
+ At this point we know the sample is not in the previous page. It could possibly be in this page. For simplicity we
+ disregard any pages that do not begin a fresh packet.
+ */
+ if ((oggbs->currentPageHeader.headerType & 0x01) == 0) { /* <-- Is it a fresh page? */
+ if (oggbs->currentPageHeader.segmentTable[0] >= 2) {
+ drflac_uint8 firstBytesInPage[2];
+ firstBytesInPage[0] = oggbs->pageData[0];
+ firstBytesInPage[1] = oggbs->pageData[1];
+
+ if ((firstBytesInPage[0] == 0xFF) && (firstBytesInPage[1] & 0xFC) == 0xF8) { /* <-- Does the page begin with a frame's sync code? */
+ runningGranulePosition = oggbs->currentPageHeader.granulePosition;
+ }
+
+ continue;
+ }
+ }
+ }
+
+ /*
+ We found the page that that is closest to the sample, so now we need to find it. The first thing to do is seek to the
+ start of that page. In the loop above we checked that it was a fresh page which means this page is also the start of
+ a new frame. This property means that after we've seeked to the page we can immediately start looping over frames until
+ we find the one containing the target sample.
+ */
+ if (!drflac_oggbs__seek_physical(oggbs, runningFrameBytePos, drflac_seek_origin_start)) {
+ return DRFLAC_FALSE;
+ }
+ if (!drflac_oggbs__goto_next_page(oggbs, drflac_ogg_recover_on_crc_mismatch)) {
+ return DRFLAC_FALSE;
+ }
+
+ /*
+ At this point we'll be sitting on the first byte of the frame header of the first frame in the page. We just keep
+ looping over these frames until we find the one containing the sample we're after.
+ */
+ runningPCMFrameCount = runningGranulePosition;
+ for (;;) {
+ /*
+ There are two ways to find the sample and seek past irrelevant frames:
+ 1) Use the native FLAC decoder.
+ 2) Use Ogg's framing system.
+
+ Both of these options have their own pros and cons. Using the native FLAC decoder is slower because it needs to
+ do a full decode of the frame. Using Ogg's framing system is faster, but more complicated and involves some code
+ duplication for the decoding of frame headers.
+
+ Another thing to consider is that using the Ogg framing system will perform direct seeking of the physical Ogg
+ bitstream. This is important to consider because it means we cannot read data from the drflac_bs object using the
+ standard drflac__*() APIs because that will read in extra data for its own internal caching which in turn breaks
+ the positioning of the read pointer of the physical Ogg bitstream. Therefore, anything that would normally be read
+ using the native FLAC decoding APIs, such as drflac__read_next_flac_frame_header(), need to be re-implemented so as to
+ avoid the use of the drflac_bs object.
+
+ Considering these issues, I have decided to use the slower native FLAC decoding method for the following reasons:
+ 1) Seeking is already partially accelerated using Ogg's paging system in the code block above.
+ 2) Seeking in an Ogg encapsulated FLAC stream is probably quite uncommon.
+ 3) Simplicity.
+ */
+ drflac_uint64 firstPCMFrameInFLACFrame = 0;
+ drflac_uint64 lastPCMFrameInFLACFrame = 0;
+ drflac_uint64 pcmFrameCountInThisFrame;
+
+ if (!drflac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) {
+ return DRFLAC_FALSE;
+ }
+
+ drflac__get_pcm_frame_range_of_current_flac_frame(pFlac, &firstPCMFrameInFLACFrame, &lastPCMFrameInFLACFrame);
+
+ pcmFrameCountInThisFrame = (lastPCMFrameInFLACFrame - firstPCMFrameInFLACFrame) + 1;
+
+ /* If we are seeking to the end of the file and we've just hit it, we're done. */
+ if (pcmFrameIndex == pFlac->totalPCMFrameCount && (runningPCMFrameCount + pcmFrameCountInThisFrame) == pFlac->totalPCMFrameCount) {
+ drflac_result result = drflac__decode_flac_frame(pFlac);
+ if (result == DRFLAC_SUCCESS) {
+ pFlac->currentPCMFrame = pcmFrameIndex;
+ pFlac->currentFLACFrame.pcmFramesRemaining = 0;
+ return DRFLAC_TRUE;
+ } else {
+ return DRFLAC_FALSE;
+ }
+ }
+
+ if (pcmFrameIndex < (runningPCMFrameCount + pcmFrameCountInThisFrame)) {
+ /*
+ The sample should be in this FLAC frame. We need to fully decode it, however if it's an invalid frame (a CRC mismatch), we need to pretend
+ it never existed and keep iterating.
+ */
+ drflac_result result = drflac__decode_flac_frame(pFlac);
+ if (result == DRFLAC_SUCCESS) {
+ /* The frame is valid. We just need to skip over some samples to ensure it's sample-exact. */
+ drflac_uint64 pcmFramesToDecode = (size_t)(pcmFrameIndex - runningPCMFrameCount); /* <-- Safe cast because the maximum number of samples in a frame is 65535. */
+ if (pcmFramesToDecode == 0) {
+ return DRFLAC_TRUE;
+ }
+
+ pFlac->currentPCMFrame = runningPCMFrameCount;
+
+ return drflac__seek_forward_by_pcm_frames(pFlac, pcmFramesToDecode) == pcmFramesToDecode; /* <-- If this fails, something bad has happened (it should never fail). */
+ } else {
+ if (result == DRFLAC_CRC_MISMATCH) {
+ continue; /* CRC mismatch. Pretend this frame never existed. */
+ } else {
+ return DRFLAC_FALSE;
+ }
+ }
+ } else {
+ /*
+ It's not in this frame. We need to seek past the frame, but check if there was a CRC mismatch. If so, we pretend this
+ frame never existed and leave the running sample count untouched.
+ */
+ drflac_result result = drflac__seek_to_next_flac_frame(pFlac);
+ if (result == DRFLAC_SUCCESS) {
+ runningPCMFrameCount += pcmFrameCountInThisFrame;
+ } else {
+ if (result == DRFLAC_CRC_MISMATCH) {
+ continue; /* CRC mismatch. Pretend this frame never existed. */
+ } else {
+ return DRFLAC_FALSE;
+ }
+ }
+ }
+ }
+}
+
+
+
+static drflac_bool32 drflac__init_private__ogg(drflac_init_info* pInit, drflac_read_proc onRead, drflac_seek_proc onSeek, drflac_meta_proc onMeta, void* pUserData, void* pUserDataMD, drflac_bool32 relaxed)
+{
+ drflac_ogg_page_header header;
+ drflac_uint32 crc32 = DRFLAC_OGG_CAPTURE_PATTERN_CRC32;
+ drflac_uint32 bytesRead = 0;
+
+ /* Pre Condition: The bit stream should be sitting just past the 4-byte OggS capture pattern. */
+ (void)relaxed;
+
+ pInit->container = drflac_container_ogg;
+ pInit->oggFirstBytePos = 0;
+
+ /*
+ We'll get here if the first 4 bytes of the stream were the OggS capture pattern, however it doesn't necessarily mean the
+ stream includes FLAC encoded audio. To check for this we need to scan the beginning-of-stream page markers and check if
+ any match the FLAC specification. Important to keep in mind that the stream may be multiplexed.
+ */
+ if (drflac_ogg__read_page_header_after_capture_pattern(onRead, pUserData, &header, &bytesRead, &crc32) != DRFLAC_SUCCESS) {
+ return DRFLAC_FALSE;
+ }
+ pInit->runningFilePos += bytesRead;
+
+ for (;;) {
+ int pageBodySize;
+
+ /* Break if we're past the beginning of stream page. */
+ if ((header.headerType & 0x02) == 0) {
+ return DRFLAC_FALSE;
+ }
+
+ /* Check if it's a FLAC header. */
+ pageBodySize = drflac_ogg__get_page_body_size(&header);
+ if (pageBodySize == 51) { /* 51 = the lacing value of the FLAC header packet. */
+ /* It could be a FLAC page... */
+ drflac_uint32 bytesRemainingInPage = pageBodySize;
+ drflac_uint8 packetType;
+
+ if (onRead(pUserData, &packetType, 1) != 1) {
+ return DRFLAC_FALSE;
+ }
+
+ bytesRemainingInPage -= 1;
+ if (packetType == 0x7F) {
+ /* Increasingly more likely to be a FLAC page... */
+ drflac_uint8 sig[4];
+ if (onRead(pUserData, sig, 4) != 4) {
+ return DRFLAC_FALSE;
+ }
+
+ bytesRemainingInPage -= 4;
+ if (sig[0] == 'F' && sig[1] == 'L' && sig[2] == 'A' && sig[3] == 'C') {
+ /* Almost certainly a FLAC page... */
+ drflac_uint8 mappingVersion[2];
+ if (onRead(pUserData, mappingVersion, 2) != 2) {
+ return DRFLAC_FALSE;
+ }
+
+ if (mappingVersion[0] != 1) {
+ return DRFLAC_FALSE; /* Only supporting version 1.x of the Ogg mapping. */
+ }
+
+ /*
+ The next 2 bytes are the non-audio packets, not including this one. We don't care about this because we're going to
+ be handling it in a generic way based on the serial number and packet types.
+ */
+ if (!onSeek(pUserData, 2, drflac_seek_origin_current)) {
+ return DRFLAC_FALSE;
+ }
+
+ /* Expecting the native FLAC signature "fLaC". */
+ if (onRead(pUserData, sig, 4) != 4) {
+ return DRFLAC_FALSE;
+ }
+
+ if (sig[0] == 'f' && sig[1] == 'L' && sig[2] == 'a' && sig[3] == 'C') {
+ /* The remaining data in the page should be the STREAMINFO block. */
+ drflac_streaminfo streaminfo;
+ drflac_uint8 isLastBlock;
+ drflac_uint8 blockType;
+ drflac_uint32 blockSize;
+ if (!drflac__read_and_decode_block_header(onRead, pUserData, &isLastBlock, &blockType, &blockSize)) {
+ return DRFLAC_FALSE;
+ }
+
+ if (blockType != DRFLAC_METADATA_BLOCK_TYPE_STREAMINFO || blockSize != 34) {
+ return DRFLAC_FALSE; /* Invalid block type. First block must be the STREAMINFO block. */
+ }
+
+ if (drflac__read_streaminfo(onRead, pUserData, &streaminfo)) {
+ /* Success! */
+ pInit->hasStreamInfoBlock = DRFLAC_TRUE;
+ pInit->sampleRate = streaminfo.sampleRate;
+ pInit->channels = streaminfo.channels;
+ pInit->bitsPerSample = streaminfo.bitsPerSample;
+ pInit->totalPCMFrameCount = streaminfo.totalPCMFrameCount;
+ pInit->maxBlockSizeInPCMFrames = streaminfo.maxBlockSizeInPCMFrames;
+ pInit->hasMetadataBlocks = !isLastBlock;
+
+ if (onMeta) {
+ drflac_metadata metadata;
+ metadata.type = DRFLAC_METADATA_BLOCK_TYPE_STREAMINFO;
+ metadata.pRawData = NULL;
+ metadata.rawDataSize = 0;
+ metadata.data.streaminfo = streaminfo;
+ onMeta(pUserDataMD, &metadata);
+ }
+
+ pInit->runningFilePos += pageBodySize;
+ pInit->oggFirstBytePos = pInit->runningFilePos - 79; /* Subtracting 79 will place us right on top of the "OggS" identifier of the FLAC bos page. */
+ pInit->oggSerial = header.serialNumber;
+ pInit->oggBosHeader = header;
+ break;
+ } else {
+ /* Failed to read STREAMINFO block. Aww, so close... */
+ return DRFLAC_FALSE;
+ }
+ } else {
+ /* Invalid file. */
+ return DRFLAC_FALSE;
+ }
+ } else {
+ /* Not a FLAC header. Skip it. */
+ if (!onSeek(pUserData, bytesRemainingInPage, drflac_seek_origin_current)) {
+ return DRFLAC_FALSE;
+ }
+ }
+ } else {
+ /* Not a FLAC header. Seek past the entire page and move on to the next. */
+ if (!onSeek(pUserData, bytesRemainingInPage, drflac_seek_origin_current)) {
+ return DRFLAC_FALSE;
+ }
+ }
+ } else {
+ if (!onSeek(pUserData, pageBodySize, drflac_seek_origin_current)) {
+ return DRFLAC_FALSE;
+ }
+ }
+
+ pInit->runningFilePos += pageBodySize;
+
+
+ /* Read the header of the next page. */
+ if (drflac_ogg__read_page_header(onRead, pUserData, &header, &bytesRead, &crc32) != DRFLAC_SUCCESS) {
+ return DRFLAC_FALSE;
+ }
+ pInit->runningFilePos += bytesRead;
+ }
+
+ /*
+ If we get here it means we found a FLAC audio stream. We should be sitting on the first byte of the header of the next page. The next
+ packets in the FLAC logical stream contain the metadata. The only thing left to do in the initialization phase for Ogg is to create the
+ Ogg bistream object.
+ */
+ pInit->hasMetadataBlocks = DRFLAC_TRUE; /* <-- Always have at least VORBIS_COMMENT metadata block. */
+ return DRFLAC_TRUE;
+}
+#endif
+
+static drflac_bool32 drflac__init_private(drflac_init_info* pInit, drflac_read_proc onRead, drflac_seek_proc onSeek, drflac_meta_proc onMeta, drflac_container container, void* pUserData, void* pUserDataMD)
+{
+ drflac_bool32 relaxed;
+ drflac_uint8 id[4];
+
+ if (pInit == NULL || onRead == NULL || onSeek == NULL) {
+ return DRFLAC_FALSE;
+ }
+
+ DRFLAC_ZERO_MEMORY(pInit, sizeof(*pInit));
+ pInit->onRead = onRead;
+ pInit->onSeek = onSeek;
+ pInit->onMeta = onMeta;
+ pInit->container = container;
+ pInit->pUserData = pUserData;
+ pInit->pUserDataMD = pUserDataMD;
+
+ pInit->bs.onRead = onRead;
+ pInit->bs.onSeek = onSeek;
+ pInit->bs.pUserData = pUserData;
+ drflac__reset_cache(&pInit->bs);
+
+
+ /* If the container is explicitly defined then we can try opening in relaxed mode. */
+ relaxed = container != drflac_container_unknown;
+
+ /* Skip over any ID3 tags. */
+ for (;;) {
+ if (onRead(pUserData, id, 4) != 4) {
+ return DRFLAC_FALSE; /* Ran out of data. */
+ }
+ pInit->runningFilePos += 4;
+
+ if (id[0] == 'I' && id[1] == 'D' && id[2] == '3') {
+ drflac_uint8 header[6];
+ drflac_uint8 flags;
+ drflac_uint32 headerSize;
+
+ if (onRead(pUserData, header, 6) != 6) {
+ return DRFLAC_FALSE; /* Ran out of data. */
+ }
+ pInit->runningFilePos += 6;
+
+ flags = header[1];
+
+ DRFLAC_COPY_MEMORY(&headerSize, header+2, 4);
+ headerSize = drflac__unsynchsafe_32(drflac__be2host_32(headerSize));
+ if (flags & 0x10) {
+ headerSize += 10;
+ }
+
+ if (!onSeek(pUserData, headerSize, drflac_seek_origin_current)) {
+ return DRFLAC_FALSE; /* Failed to seek past the tag. */
+ }
+ pInit->runningFilePos += headerSize;
+ } else {
+ break;
+ }
+ }
+
+ if (id[0] == 'f' && id[1] == 'L' && id[2] == 'a' && id[3] == 'C') {
+ return drflac__init_private__native(pInit, onRead, onSeek, onMeta, pUserData, pUserDataMD, relaxed);
+ }
+#ifndef DR_FLAC_NO_OGG
+ if (id[0] == 'O' && id[1] == 'g' && id[2] == 'g' && id[3] == 'S') {
+ return drflac__init_private__ogg(pInit, onRead, onSeek, onMeta, pUserData, pUserDataMD, relaxed);
+ }
+#endif
+
+ /* If we get here it means we likely don't have a header. Try opening in relaxed mode, if applicable. */
+ if (relaxed) {
+ if (container == drflac_container_native) {
+ return drflac__init_private__native(pInit, onRead, onSeek, onMeta, pUserData, pUserDataMD, relaxed);
+ }
+#ifndef DR_FLAC_NO_OGG
+ if (container == drflac_container_ogg) {
+ return drflac__init_private__ogg(pInit, onRead, onSeek, onMeta, pUserData, pUserDataMD, relaxed);
+ }
+#endif
+ }
+
+ /* Unsupported container. */
+ return DRFLAC_FALSE;
+}
+
+static void drflac__init_from_info(drflac* pFlac, const drflac_init_info* pInit)
+{
+ DRFLAC_ASSERT(pFlac != NULL);
+ DRFLAC_ASSERT(pInit != NULL);
+
+ DRFLAC_ZERO_MEMORY(pFlac, sizeof(*pFlac));
+ pFlac->bs = pInit->bs;
+ pFlac->onMeta = pInit->onMeta;
+ pFlac->pUserDataMD = pInit->pUserDataMD;
+ pFlac->maxBlockSizeInPCMFrames = pInit->maxBlockSizeInPCMFrames;
+ pFlac->sampleRate = pInit->sampleRate;
+ pFlac->channels = (drflac_uint8)pInit->channels;
+ pFlac->bitsPerSample = (drflac_uint8)pInit->bitsPerSample;
+ pFlac->totalPCMFrameCount = pInit->totalPCMFrameCount;
+ pFlac->container = pInit->container;
+}
+
+
+static drflac* drflac_open_with_metadata_private(drflac_read_proc onRead, drflac_seek_proc onSeek, drflac_meta_proc onMeta, drflac_container container, void* pUserData, void* pUserDataMD, const drflac_allocation_callbacks* pAllocationCallbacks)
+{
+ drflac_init_info init;
+ drflac_uint32 allocationSize;
+ drflac_uint32 wholeSIMDVectorCountPerChannel;
+ drflac_uint32 decodedSamplesAllocationSize;
+#ifndef DR_FLAC_NO_OGG
+ drflac_oggbs* pOggbs = NULL;
+#endif
+ drflac_uint64 firstFramePos;
+ drflac_uint64 seektablePos;
+ drflac_uint32 seekpointCount;
+ drflac_allocation_callbacks allocationCallbacks;
+ drflac* pFlac;
+
+ /* CPU support first. */
+ drflac__init_cpu_caps();
+
+ if (!drflac__init_private(&init, onRead, onSeek, onMeta, container, pUserData, pUserDataMD)) {
+ return NULL;
+ }
+
+ if (pAllocationCallbacks != NULL) {
+ allocationCallbacks = *pAllocationCallbacks;
+ if (allocationCallbacks.onFree == NULL || (allocationCallbacks.onMalloc == NULL && allocationCallbacks.onRealloc == NULL)) {
+ return NULL; /* Invalid allocation callbacks. */
+ }
+ } else {
+ allocationCallbacks.pUserData = NULL;
+ allocationCallbacks.onMalloc = drflac__malloc_default;
+ allocationCallbacks.onRealloc = drflac__realloc_default;
+ allocationCallbacks.onFree = drflac__free_default;
+ }
+
+
+ /*
+ The size of the allocation for the drflac object needs to be large enough to fit the following:
+ 1) The main members of the drflac structure
+ 2) A block of memory large enough to store the decoded samples of the largest frame in the stream
+ 3) If the container is Ogg, a drflac_oggbs object
+
+ The complicated part of the allocation is making sure there's enough room the decoded samples, taking into consideration
+ the different SIMD instruction sets.
+ */
+ allocationSize = sizeof(drflac);
+
+ /*
+ The allocation size for decoded frames depends on the number of 32-bit integers that fit inside the largest SIMD vector
+ we are supporting.
+ */
+ if ((init.maxBlockSizeInPCMFrames % (DRFLAC_MAX_SIMD_VECTOR_SIZE / sizeof(drflac_int32))) == 0) {
+ wholeSIMDVectorCountPerChannel = (init.maxBlockSizeInPCMFrames / (DRFLAC_MAX_SIMD_VECTOR_SIZE / sizeof(drflac_int32)));
+ } else {
+ wholeSIMDVectorCountPerChannel = (init.maxBlockSizeInPCMFrames / (DRFLAC_MAX_SIMD_VECTOR_SIZE / sizeof(drflac_int32))) + 1;
+ }
+
+ decodedSamplesAllocationSize = wholeSIMDVectorCountPerChannel * DRFLAC_MAX_SIMD_VECTOR_SIZE * init.channels;
+
+ allocationSize += decodedSamplesAllocationSize;
+ allocationSize += DRFLAC_MAX_SIMD_VECTOR_SIZE; /* Allocate extra bytes to ensure we have enough for alignment. */
+
+#ifndef DR_FLAC_NO_OGG
+ /* There's additional data required for Ogg streams. */
+ if (init.container == drflac_container_ogg) {
+ allocationSize += sizeof(drflac_oggbs);
+
+ pOggbs = (drflac_oggbs*)drflac__malloc_from_callbacks(sizeof(*pOggbs), &allocationCallbacks);
+ if (pOggbs == NULL) {
+ return NULL; /*DRFLAC_OUT_OF_MEMORY;*/
+ }
+
+ DRFLAC_ZERO_MEMORY(pOggbs, sizeof(*pOggbs));
+ pOggbs->onRead = onRead;
+ pOggbs->onSeek = onSeek;
+ pOggbs->pUserData = pUserData;
+ pOggbs->currentBytePos = init.oggFirstBytePos;
+ pOggbs->firstBytePos = init.oggFirstBytePos;
+ pOggbs->serialNumber = init.oggSerial;
+ pOggbs->bosPageHeader = init.oggBosHeader;
+ pOggbs->bytesRemainingInPage = 0;
+ }
+#endif
+
+ /*
+ This part is a bit awkward. We need to load the seektable so that it can be referenced in-memory, but I want the drflac object to
+ consist of only a single heap allocation. To this, the size of the seek table needs to be known, which we determine when reading
+ and decoding the metadata.
+ */
+ firstFramePos = 42; /* <-- We know we are at byte 42 at this point. */
+ seektablePos = 0;
+ seekpointCount = 0;
+ if (init.hasMetadataBlocks) {
+ drflac_read_proc onReadOverride = onRead;
+ drflac_seek_proc onSeekOverride = onSeek;
+ void* pUserDataOverride = pUserData;
+
+#ifndef DR_FLAC_NO_OGG
+ if (init.container == drflac_container_ogg) {
+ onReadOverride = drflac__on_read_ogg;
+ onSeekOverride = drflac__on_seek_ogg;
+ pUserDataOverride = (void*)pOggbs;
+ }
+#endif
+
+ if (!drflac__read_and_decode_metadata(onReadOverride, onSeekOverride, onMeta, pUserDataOverride, pUserDataMD, &firstFramePos, &seektablePos, &seekpointCount, &allocationCallbacks)) {
+ #ifndef DR_FLAC_NO_OGG
+ drflac__free_from_callbacks(pOggbs, &allocationCallbacks);
+ #endif
+ return NULL;
+ }
+
+ allocationSize += seekpointCount * sizeof(drflac_seekpoint);
+ }
+
+
+ pFlac = (drflac*)drflac__malloc_from_callbacks(allocationSize, &allocationCallbacks);
+ if (pFlac == NULL) {
+ #ifndef DR_FLAC_NO_OGG
+ drflac__free_from_callbacks(pOggbs, &allocationCallbacks);
+ #endif
+ return NULL;
+ }
+
+ drflac__init_from_info(pFlac, &init);
+ pFlac->allocationCallbacks = allocationCallbacks;
+ pFlac->pDecodedSamples = (drflac_int32*)drflac_align((size_t)pFlac->pExtraData, DRFLAC_MAX_SIMD_VECTOR_SIZE);
+
+#ifndef DR_FLAC_NO_OGG
+ if (init.container == drflac_container_ogg) {
+ drflac_oggbs* pInternalOggbs = (drflac_oggbs*)((drflac_uint8*)pFlac->pDecodedSamples + decodedSamplesAllocationSize + (seekpointCount * sizeof(drflac_seekpoint)));
+ DRFLAC_COPY_MEMORY(pInternalOggbs, pOggbs, sizeof(*pOggbs));
+
+ /* At this point the pOggbs object has been handed over to pInternalOggbs and can be freed. */
+ drflac__free_from_callbacks(pOggbs, &allocationCallbacks);
+ pOggbs = NULL;
+
+ /* The Ogg bistream needs to be layered on top of the original bitstream. */
+ pFlac->bs.onRead = drflac__on_read_ogg;
+ pFlac->bs.onSeek = drflac__on_seek_ogg;
+ pFlac->bs.pUserData = (void*)pInternalOggbs;
+ pFlac->_oggbs = (void*)pInternalOggbs;
+ }
+#endif
+
+ pFlac->firstFLACFramePosInBytes = firstFramePos;
+
+ /* NOTE: Seektables are not currently compatible with Ogg encapsulation (Ogg has its own accelerated seeking system). I may change this later, so I'm leaving this here for now. */
+#ifndef DR_FLAC_NO_OGG
+ if (init.container == drflac_container_ogg)
+ {
+ pFlac->pSeekpoints = NULL;
+ pFlac->seekpointCount = 0;
+ }
+ else
+#endif
+ {
+ /* If we have a seektable we need to load it now, making sure we move back to where we were previously. */
+ if (seektablePos != 0) {
+ pFlac->seekpointCount = seekpointCount;
+ pFlac->pSeekpoints = (drflac_seekpoint*)((drflac_uint8*)pFlac->pDecodedSamples + decodedSamplesAllocationSize);
+
+ DRFLAC_ASSERT(pFlac->bs.onSeek != NULL);
+ DRFLAC_ASSERT(pFlac->bs.onRead != NULL);
+
+ /* Seek to the seektable, then just read directly into our seektable buffer. */
+ if (pFlac->bs.onSeek(pFlac->bs.pUserData, (int)seektablePos, drflac_seek_origin_start)) {
+ drflac_uint32 iSeekpoint;
+
+ for (iSeekpoint = 0; iSeekpoint < seekpointCount; iSeekpoint += 1) {
+ if (pFlac->bs.onRead(pFlac->bs.pUserData, pFlac->pSeekpoints + iSeekpoint, DRFLAC_SEEKPOINT_SIZE_IN_BYTES) == DRFLAC_SEEKPOINT_SIZE_IN_BYTES) {
+ /* Endian swap. */
+ pFlac->pSeekpoints[iSeekpoint].firstPCMFrame = drflac__be2host_64(pFlac->pSeekpoints[iSeekpoint].firstPCMFrame);
+ pFlac->pSeekpoints[iSeekpoint].flacFrameOffset = drflac__be2host_64(pFlac->pSeekpoints[iSeekpoint].flacFrameOffset);
+ pFlac->pSeekpoints[iSeekpoint].pcmFrameCount = drflac__be2host_16(pFlac->pSeekpoints[iSeekpoint].pcmFrameCount);
+ } else {
+ /* Failed to read the seektable. Pretend we don't have one. */
+ pFlac->pSeekpoints = NULL;
+ pFlac->seekpointCount = 0;
+ break;
+ }
+ }
+
+ /* We need to seek back to where we were. If this fails it's a critical error. */
+ if (!pFlac->bs.onSeek(pFlac->bs.pUserData, (int)pFlac->firstFLACFramePosInBytes, drflac_seek_origin_start)) {
+ drflac__free_from_callbacks(pFlac, &allocationCallbacks);
+ return NULL;
+ }
+ } else {
+ /* Failed to seek to the seektable. Ominous sign, but for now we can just pretend we don't have one. */
+ pFlac->pSeekpoints = NULL;
+ pFlac->seekpointCount = 0;
+ }
+ }
+ }
+
+
+ /*
+ If we get here, but don't have a STREAMINFO block, it means we've opened the stream in relaxed mode and need to decode
+ the first frame.
+ */
+ if (!init.hasStreamInfoBlock) {
+ pFlac->currentFLACFrame.header = init.firstFrameHeader;
+ for (;;) {
+ drflac_result result = drflac__decode_flac_frame(pFlac);
+ if (result == DRFLAC_SUCCESS) {
+ break;
+ } else {
+ if (result == DRFLAC_CRC_MISMATCH) {
+ if (!drflac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) {
+ drflac__free_from_callbacks(pFlac, &allocationCallbacks);
+ return NULL;
+ }
+ continue;
+ } else {
+ drflac__free_from_callbacks(pFlac, &allocationCallbacks);
+ return NULL;
+ }
+ }
+ }
+ }
+
+ return pFlac;
+}
+
+
+
+#ifndef DR_FLAC_NO_STDIO
+#include <stdio.h>
+#ifndef DR_FLAC_NO_WCHAR
+#include <wchar.h> /* For wcslen(), wcsrtombs() */
+#endif
+
+/* Errno */
+/* drflac_result_from_errno() is only used for fopen() and wfopen() so putting it inside DR_WAV_NO_STDIO for now. If something else needs this later we can move it out. */
+#include <errno.h>
+static drflac_result drflac_result_from_errno(int e)
+{
+ switch (e)
+ {
+ case 0: return DRFLAC_SUCCESS;
+ #ifdef EPERM
+ case EPERM: return DRFLAC_INVALID_OPERATION;
+ #endif
+ #ifdef ENOENT
+ case ENOENT: return DRFLAC_DOES_NOT_EXIST;
+ #endif
+ #ifdef ESRCH
+ case ESRCH: return DRFLAC_DOES_NOT_EXIST;
+ #endif
+ #ifdef EINTR
+ case EINTR: return DRFLAC_INTERRUPT;
+ #endif
+ #ifdef EIO
+ case EIO: return DRFLAC_IO_ERROR;
+ #endif
+ #ifdef ENXIO
+ case ENXIO: return DRFLAC_DOES_NOT_EXIST;
+ #endif
+ #ifdef E2BIG
+ case E2BIG: return DRFLAC_INVALID_ARGS;
+ #endif
+ #ifdef ENOEXEC
+ case ENOEXEC: return DRFLAC_INVALID_FILE;
+ #endif
+ #ifdef EBADF
+ case EBADF: return DRFLAC_INVALID_FILE;
+ #endif
+ #ifdef ECHILD
+ case ECHILD: return DRFLAC_ERROR;
+ #endif
+ #ifdef EAGAIN
+ case EAGAIN: return DRFLAC_UNAVAILABLE;
+ #endif
+ #ifdef ENOMEM
+ case ENOMEM: return DRFLAC_OUT_OF_MEMORY;
+ #endif
+ #ifdef EACCES
+ case EACCES: return DRFLAC_ACCESS_DENIED;
+ #endif
+ #ifdef EFAULT
+ case EFAULT: return DRFLAC_BAD_ADDRESS;
+ #endif
+ #ifdef ENOTBLK
+ case ENOTBLK: return DRFLAC_ERROR;
+ #endif
+ #ifdef EBUSY
+ case EBUSY: return DRFLAC_BUSY;
+ #endif
+ #ifdef EEXIST
+ case EEXIST: return DRFLAC_ALREADY_EXISTS;
+ #endif
+ #ifdef EXDEV
+ case EXDEV: return DRFLAC_ERROR;
+ #endif
+ #ifdef ENODEV
+ case ENODEV: return DRFLAC_DOES_NOT_EXIST;
+ #endif
+ #ifdef ENOTDIR
+ case ENOTDIR: return DRFLAC_NOT_DIRECTORY;
+ #endif
+ #ifdef EISDIR
+ case EISDIR: return DRFLAC_IS_DIRECTORY;
+ #endif
+ #ifdef EINVAL
+ case EINVAL: return DRFLAC_INVALID_ARGS;
+ #endif
+ #ifdef ENFILE
+ case ENFILE: return DRFLAC_TOO_MANY_OPEN_FILES;
+ #endif
+ #ifdef EMFILE
+ case EMFILE: return DRFLAC_TOO_MANY_OPEN_FILES;
+ #endif
+ #ifdef ENOTTY
+ case ENOTTY: return DRFLAC_INVALID_OPERATION;
+ #endif
+ #ifdef ETXTBSY
+ case ETXTBSY: return DRFLAC_BUSY;
+ #endif
+ #ifdef EFBIG
+ case EFBIG: return DRFLAC_TOO_BIG;
+ #endif
+ #ifdef ENOSPC
+ case ENOSPC: return DRFLAC_NO_SPACE;
+ #endif
+ #ifdef ESPIPE
+ case ESPIPE: return DRFLAC_BAD_SEEK;
+ #endif
+ #ifdef EROFS
+ case EROFS: return DRFLAC_ACCESS_DENIED;
+ #endif
+ #ifdef EMLINK
+ case EMLINK: return DRFLAC_TOO_MANY_LINKS;
+ #endif
+ #ifdef EPIPE
+ case EPIPE: return DRFLAC_BAD_PIPE;
+ #endif
+ #ifdef EDOM
+ case EDOM: return DRFLAC_OUT_OF_RANGE;
+ #endif
+ #ifdef ERANGE
+ case ERANGE: return DRFLAC_OUT_OF_RANGE;
+ #endif
+ #ifdef EDEADLK
+ case EDEADLK: return DRFLAC_DEADLOCK;
+ #endif
+ #ifdef ENAMETOOLONG
+ case ENAMETOOLONG: return DRFLAC_PATH_TOO_LONG;
+ #endif
+ #ifdef ENOLCK
+ case ENOLCK: return DRFLAC_ERROR;
+ #endif
+ #ifdef ENOSYS
+ case ENOSYS: return DRFLAC_NOT_IMPLEMENTED;
+ #endif
+ #ifdef ENOTEMPTY
+ case ENOTEMPTY: return DRFLAC_DIRECTORY_NOT_EMPTY;
+ #endif
+ #ifdef ELOOP
+ case ELOOP: return DRFLAC_TOO_MANY_LINKS;
+ #endif
+ #ifdef ENOMSG
+ case ENOMSG: return DRFLAC_NO_MESSAGE;
+ #endif
+ #ifdef EIDRM
+ case EIDRM: return DRFLAC_ERROR;
+ #endif
+ #ifdef ECHRNG
+ case ECHRNG: return DRFLAC_ERROR;
+ #endif
+ #ifdef EL2NSYNC
+ case EL2NSYNC: return DRFLAC_ERROR;
+ #endif
+ #ifdef EL3HLT
+ case EL3HLT: return DRFLAC_ERROR;
+ #endif
+ #ifdef EL3RST
+ case EL3RST: return DRFLAC_ERROR;
+ #endif
+ #ifdef ELNRNG
+ case ELNRNG: return DRFLAC_OUT_OF_RANGE;
+ #endif
+ #ifdef EUNATCH
+ case EUNATCH: return DRFLAC_ERROR;
+ #endif
+ #ifdef ENOCSI
+ case ENOCSI: return DRFLAC_ERROR;
+ #endif
+ #ifdef EL2HLT
+ case EL2HLT: return DRFLAC_ERROR;
+ #endif
+ #ifdef EBADE
+ case EBADE: return DRFLAC_ERROR;
+ #endif
+ #ifdef EBADR
+ case EBADR: return DRFLAC_ERROR;
+ #endif
+ #ifdef EXFULL
+ case EXFULL: return DRFLAC_ERROR;
+ #endif
+ #ifdef ENOANO
+ case ENOANO: return DRFLAC_ERROR;
+ #endif
+ #ifdef EBADRQC
+ case EBADRQC: return DRFLAC_ERROR;
+ #endif
+ #ifdef EBADSLT
+ case EBADSLT: return DRFLAC_ERROR;
+ #endif
+ #ifdef EBFONT
+ case EBFONT: return DRFLAC_INVALID_FILE;
+ #endif
+ #ifdef ENOSTR
+ case ENOSTR: return DRFLAC_ERROR;
+ #endif
+ #ifdef ENODATA
+ case ENODATA: return DRFLAC_NO_DATA_AVAILABLE;
+ #endif
+ #ifdef ETIME
+ case ETIME: return DRFLAC_TIMEOUT;
+ #endif
+ #ifdef ENOSR
+ case ENOSR: return DRFLAC_NO_DATA_AVAILABLE;
+ #endif
+ #ifdef ENONET
+ case ENONET: return DRFLAC_NO_NETWORK;
+ #endif
+ #ifdef ENOPKG
+ case ENOPKG: return DRFLAC_ERROR;
+ #endif
+ #ifdef EREMOTE
+ case EREMOTE: return DRFLAC_ERROR;
+ #endif
+ #ifdef ENOLINK
+ case ENOLINK: return DRFLAC_ERROR;
+ #endif
+ #ifdef EADV
+ case EADV: return DRFLAC_ERROR;
+ #endif
+ #ifdef ESRMNT
+ case ESRMNT: return DRFLAC_ERROR;
+ #endif
+ #ifdef ECOMM
+ case ECOMM: return DRFLAC_ERROR;
+ #endif
+ #ifdef EPROTO
+ case EPROTO: return DRFLAC_ERROR;
+ #endif
+ #ifdef EMULTIHOP
+ case EMULTIHOP: return DRFLAC_ERROR;
+ #endif
+ #ifdef EDOTDOT
+ case EDOTDOT: return DRFLAC_ERROR;
+ #endif
+ #ifdef EBADMSG
+ case EBADMSG: return DRFLAC_BAD_MESSAGE;
+ #endif
+ #ifdef EOVERFLOW
+ case EOVERFLOW: return DRFLAC_TOO_BIG;
+ #endif
+ #ifdef ENOTUNIQ
+ case ENOTUNIQ: return DRFLAC_NOT_UNIQUE;
+ #endif
+ #ifdef EBADFD
+ case EBADFD: return DRFLAC_ERROR;
+ #endif
+ #ifdef EREMCHG
+ case EREMCHG: return DRFLAC_ERROR;
+ #endif
+ #ifdef ELIBACC
+ case ELIBACC: return DRFLAC_ACCESS_DENIED;
+ #endif
+ #ifdef ELIBBAD
+ case ELIBBAD: return DRFLAC_INVALID_FILE;
+ #endif
+ #ifdef ELIBSCN
+ case ELIBSCN: return DRFLAC_INVALID_FILE;
+ #endif
+ #ifdef ELIBMAX
+ case ELIBMAX: return DRFLAC_ERROR;
+ #endif
+ #ifdef ELIBEXEC
+ case ELIBEXEC: return DRFLAC_ERROR;
+ #endif
+ #ifdef EILSEQ
+ case EILSEQ: return DRFLAC_INVALID_DATA;
+ #endif
+ #ifdef ERESTART
+ case ERESTART: return DRFLAC_ERROR;
+ #endif
+ #ifdef ESTRPIPE
+ case ESTRPIPE: return DRFLAC_ERROR;
+ #endif
+ #ifdef EUSERS
+ case EUSERS: return DRFLAC_ERROR;
+ #endif
+ #ifdef ENOTSOCK
+ case ENOTSOCK: return DRFLAC_NOT_SOCKET;
+ #endif
+ #ifdef EDESTADDRREQ
+ case EDESTADDRREQ: return DRFLAC_NO_ADDRESS;
+ #endif
+ #ifdef EMSGSIZE
+ case EMSGSIZE: return DRFLAC_TOO_BIG;
+ #endif
+ #ifdef EPROTOTYPE
+ case EPROTOTYPE: return DRFLAC_BAD_PROTOCOL;
+ #endif
+ #ifdef ENOPROTOOPT
+ case ENOPROTOOPT: return DRFLAC_PROTOCOL_UNAVAILABLE;
+ #endif
+ #ifdef EPROTONOSUPPORT
+ case EPROTONOSUPPORT: return DRFLAC_PROTOCOL_NOT_SUPPORTED;
+ #endif
+ #ifdef ESOCKTNOSUPPORT
+ case ESOCKTNOSUPPORT: return DRFLAC_SOCKET_NOT_SUPPORTED;
+ #endif
+ #ifdef EOPNOTSUPP
+ case EOPNOTSUPP: return DRFLAC_INVALID_OPERATION;
+ #endif
+ #ifdef EPFNOSUPPORT
+ case EPFNOSUPPORT: return DRFLAC_PROTOCOL_FAMILY_NOT_SUPPORTED;
+ #endif
+ #ifdef EAFNOSUPPORT
+ case EAFNOSUPPORT: return DRFLAC_ADDRESS_FAMILY_NOT_SUPPORTED;
+ #endif
+ #ifdef EADDRINUSE
+ case EADDRINUSE: return DRFLAC_ALREADY_IN_USE;
+ #endif
+ #ifdef EADDRNOTAVAIL
+ case EADDRNOTAVAIL: return DRFLAC_ERROR;
+ #endif
+ #ifdef ENETDOWN
+ case ENETDOWN: return DRFLAC_NO_NETWORK;
+ #endif
+ #ifdef ENETUNREACH
+ case ENETUNREACH: return DRFLAC_NO_NETWORK;
+ #endif
+ #ifdef ENETRESET
+ case ENETRESET: return DRFLAC_NO_NETWORK;
+ #endif
+ #ifdef ECONNABORTED
+ case ECONNABORTED: return DRFLAC_NO_NETWORK;
+ #endif
+ #ifdef ECONNRESET
+ case ECONNRESET: return DRFLAC_CONNECTION_RESET;
+ #endif
+ #ifdef ENOBUFS
+ case ENOBUFS: return DRFLAC_NO_SPACE;
+ #endif
+ #ifdef EISCONN
+ case EISCONN: return DRFLAC_ALREADY_CONNECTED;
+ #endif
+ #ifdef ENOTCONN
+ case ENOTCONN: return DRFLAC_NOT_CONNECTED;
+ #endif
+ #ifdef ESHUTDOWN
+ case ESHUTDOWN: return DRFLAC_ERROR;
+ #endif
+ #ifdef ETOOMANYREFS
+ case ETOOMANYREFS: return DRFLAC_ERROR;
+ #endif
+ #ifdef ETIMEDOUT
+ case ETIMEDOUT: return DRFLAC_TIMEOUT;
+ #endif
+ #ifdef ECONNREFUSED
+ case ECONNREFUSED: return DRFLAC_CONNECTION_REFUSED;
+ #endif
+ #ifdef EHOSTDOWN
+ case EHOSTDOWN: return DRFLAC_NO_HOST;
+ #endif
+ #ifdef EHOSTUNREACH
+ case EHOSTUNREACH: return DRFLAC_NO_HOST;
+ #endif
+ #ifdef EALREADY
+ case EALREADY: return DRFLAC_IN_PROGRESS;
+ #endif
+ #ifdef EINPROGRESS
+ case EINPROGRESS: return DRFLAC_IN_PROGRESS;
+ #endif
+ #ifdef ESTALE
+ case ESTALE: return DRFLAC_INVALID_FILE;
+ #endif
+ #ifdef EUCLEAN
+ case EUCLEAN: return DRFLAC_ERROR;
+ #endif
+ #ifdef ENOTNAM
+ case ENOTNAM: return DRFLAC_ERROR;
+ #endif
+ #ifdef ENAVAIL
+ case ENAVAIL: return DRFLAC_ERROR;
+ #endif
+ #ifdef EISNAM
+ case EISNAM: return DRFLAC_ERROR;
+ #endif
+ #ifdef EREMOTEIO
+ case EREMOTEIO: return DRFLAC_IO_ERROR;
+ #endif
+ #ifdef EDQUOT
+ case EDQUOT: return DRFLAC_NO_SPACE;
+ #endif
+ #ifdef ENOMEDIUM
+ case ENOMEDIUM: return DRFLAC_DOES_NOT_EXIST;
+ #endif
+ #ifdef EMEDIUMTYPE
+ case EMEDIUMTYPE: return DRFLAC_ERROR;
+ #endif
+ #ifdef ECANCELED
+ case ECANCELED: return DRFLAC_CANCELLED;
+ #endif
+ #ifdef ENOKEY
+ case ENOKEY: return DRFLAC_ERROR;
+ #endif
+ #ifdef EKEYEXPIRED
+ case EKEYEXPIRED: return DRFLAC_ERROR;
+ #endif
+ #ifdef EKEYREVOKED
+ case EKEYREVOKED: return DRFLAC_ERROR;
+ #endif
+ #ifdef EKEYREJECTED
+ case EKEYREJECTED: return DRFLAC_ERROR;
+ #endif
+ #ifdef EOWNERDEAD
+ case EOWNERDEAD: return DRFLAC_ERROR;
+ #endif
+ #ifdef ENOTRECOVERABLE
+ case ENOTRECOVERABLE: return DRFLAC_ERROR;
+ #endif
+ #ifdef ERFKILL
+ case ERFKILL: return DRFLAC_ERROR;
+ #endif
+ #ifdef EHWPOISON
+ case EHWPOISON: return DRFLAC_ERROR;
+ #endif
+ default: return DRFLAC_ERROR;
+ }
+}
+/* End Errno */
+
+/* fopen */
+static drflac_result drflac_fopen(FILE** ppFile, const char* pFilePath, const char* pOpenMode)
+{
+#if defined(_MSC_VER) && _MSC_VER >= 1400
+ errno_t err;
+#endif
+
+ if (ppFile != NULL) {
+ *ppFile = NULL; /* Safety. */
+ }
+
+ if (pFilePath == NULL || pOpenMode == NULL || ppFile == NULL) {
+ return DRFLAC_INVALID_ARGS;
+ }
+
+#if defined(_MSC_VER) && _MSC_VER >= 1400
+ err = fopen_s(ppFile, pFilePath, pOpenMode);
+ if (err != 0) {
+ return drflac_result_from_errno(err);
+ }
+#else
+#if defined(_WIN32) || defined(__APPLE__)
+ *ppFile = fopen(pFilePath, pOpenMode);
+#else
+ #if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS == 64 && defined(_LARGEFILE64_SOURCE)
+ *ppFile = fopen64(pFilePath, pOpenMode);
+ #else
+ *ppFile = fopen(pFilePath, pOpenMode);
+ #endif
+#endif
+ if (*ppFile == NULL) {
+ drflac_result result = drflac_result_from_errno(errno);
+ if (result == DRFLAC_SUCCESS) {
+ result = DRFLAC_ERROR; /* Just a safety check to make sure we never ever return success when pFile == NULL. */
+ }
+
+ return result;
+ }
+#endif
+
+ return DRFLAC_SUCCESS;
+}
+
+/*
+_wfopen() isn't always available in all compilation environments.
+
+ * Windows only.
+ * MSVC seems to support it universally as far back as VC6 from what I can tell (haven't checked further back).
+ * MinGW-64 (both 32- and 64-bit) seems to support it.
+ * MinGW wraps it in !defined(__STRICT_ANSI__).
+ * OpenWatcom wraps it in !defined(_NO_EXT_KEYS).
+
+This can be reviewed as compatibility issues arise. The preference is to use _wfopen_s() and _wfopen() as opposed to the wcsrtombs()
+fallback, so if you notice your compiler not detecting this properly I'm happy to look at adding support.
+*/
+#if defined(_WIN32)
+ #if defined(_MSC_VER) || defined(__MINGW64__) || (!defined(__STRICT_ANSI__) && !defined(_NO_EXT_KEYS))
+ #define DRFLAC_HAS_WFOPEN
+ #endif
+#endif
+
+#ifndef DR_FLAC_NO_WCHAR
+static drflac_result drflac_wfopen(FILE** ppFile, const wchar_t* pFilePath, const wchar_t* pOpenMode, const drflac_allocation_callbacks* pAllocationCallbacks)
+{
+ if (ppFile != NULL) {
+ *ppFile = NULL; /* Safety. */
+ }
+
+ if (pFilePath == NULL || pOpenMode == NULL || ppFile == NULL) {
+ return DRFLAC_INVALID_ARGS;
+ }
+
+#if defined(DRFLAC_HAS_WFOPEN)
+ {
+ /* Use _wfopen() on Windows. */
+ #if defined(_MSC_VER) && _MSC_VER >= 1400
+ errno_t err = _wfopen_s(ppFile, pFilePath, pOpenMode);
+ if (err != 0) {
+ return drflac_result_from_errno(err);
+ }
+ #else
+ *ppFile = _wfopen(pFilePath, pOpenMode);
+ if (*ppFile == NULL) {
+ return drflac_result_from_errno(errno);
+ }
+ #endif
+ (void)pAllocationCallbacks;
+ }
+#else
+ /*
+ Use fopen() on anything other than Windows. Requires a conversion. This is annoying because
+ fopen() is locale specific. The only real way I can think of to do this is with wcsrtombs(). Note
+ that wcstombs() is apparently not thread-safe because it uses a static global mbstate_t object for
+ maintaining state. I've checked this with -std=c89 and it works, but if somebody get's a compiler
+ error I'll look into improving compatibility.
+ */
+
+ /*
+ Some compilers don't support wchar_t or wcsrtombs() which we're using below. In this case we just
+ need to abort with an error. If you encounter a compiler lacking such support, add it to this list
+ and submit a bug report and it'll be added to the library upstream.
+ */
+ #if defined(__DJGPP__)
+ {
+ /* Nothing to do here. This will fall through to the error check below. */
+ }
+ #else
+ {
+ mbstate_t mbs;
+ size_t lenMB;
+ const wchar_t* pFilePathTemp = pFilePath;
+ char* pFilePathMB = NULL;
+ char pOpenModeMB[32] = {0};
+
+ /* Get the length first. */
+ DRFLAC_ZERO_OBJECT(&mbs);
+ lenMB = wcsrtombs(NULL, &pFilePathTemp, 0, &mbs);
+ if (lenMB == (size_t)-1) {
+ return drflac_result_from_errno(errno);
+ }
+
+ pFilePathMB = (char*)drflac__malloc_from_callbacks(lenMB + 1, pAllocationCallbacks);
+ if (pFilePathMB == NULL) {
+ return DRFLAC_OUT_OF_MEMORY;
+ }
+
+ pFilePathTemp = pFilePath;
+ DRFLAC_ZERO_OBJECT(&mbs);
+ wcsrtombs(pFilePathMB, &pFilePathTemp, lenMB + 1, &mbs);
+
+ /* The open mode should always consist of ASCII characters so we should be able to do a trivial conversion. */
+ {
+ size_t i = 0;
+ for (;;) {
+ if (pOpenMode[i] == 0) {
+ pOpenModeMB[i] = '\0';
+ break;
+ }
+
+ pOpenModeMB[i] = (char)pOpenMode[i];
+ i += 1;
+ }
+ }
+
+ *ppFile = fopen(pFilePathMB, pOpenModeMB);
+
+ drflac__free_from_callbacks(pFilePathMB, pAllocationCallbacks);
+ }
+ #endif
+
+ if (*ppFile == NULL) {
+ return DRFLAC_ERROR;
+ }
+#endif
+
+ return DRFLAC_SUCCESS;
+}
+#endif
+/* End fopen */
+
+static size_t drflac__on_read_stdio(void* pUserData, void* bufferOut, size_t bytesToRead)
+{
+ return fread(bufferOut, 1, bytesToRead, (FILE*)pUserData);
+}
+
+static drflac_bool32 drflac__on_seek_stdio(void* pUserData, int offset, drflac_seek_origin origin)
+{
+ DRFLAC_ASSERT(offset >= 0); /* <-- Never seek backwards. */
+
+ return fseek((FILE*)pUserData, offset, (origin == drflac_seek_origin_current) ? SEEK_CUR : SEEK_SET) == 0;
+}
+
+
+DRFLAC_API drflac* drflac_open_file(const char* pFileName, const drflac_allocation_callbacks* pAllocationCallbacks)
+{
+ drflac* pFlac;
+ FILE* pFile;
+
+ if (drflac_fopen(&pFile, pFileName, "rb") != DRFLAC_SUCCESS) {
+ return NULL;
+ }
+
+ pFlac = drflac_open(drflac__on_read_stdio, drflac__on_seek_stdio, (void*)pFile, pAllocationCallbacks);
+ if (pFlac == NULL) {
+ fclose(pFile);
+ return NULL;
+ }
+
+ return pFlac;
+}
+
+#ifndef DR_FLAC_NO_WCHAR
+DRFLAC_API drflac* drflac_open_file_w(const wchar_t* pFileName, const drflac_allocation_callbacks* pAllocationCallbacks)
+{
+ drflac* pFlac;
+ FILE* pFile;
+
+ if (drflac_wfopen(&pFile, pFileName, L"rb", pAllocationCallbacks) != DRFLAC_SUCCESS) {
+ return NULL;
+ }
+
+ pFlac = drflac_open(drflac__on_read_stdio, drflac__on_seek_stdio, (void*)pFile, pAllocationCallbacks);
+ if (pFlac == NULL) {
+ fclose(pFile);
+ return NULL;
+ }
+
+ return pFlac;
+}
+#endif
+
+DRFLAC_API drflac* drflac_open_file_with_metadata(const char* pFileName, drflac_meta_proc onMeta, void* pUserData, const drflac_allocation_callbacks* pAllocationCallbacks)
+{
+ drflac* pFlac;
+ FILE* pFile;
+
+ if (drflac_fopen(&pFile, pFileName, "rb") != DRFLAC_SUCCESS) {
+ return NULL;
+ }
+
+ pFlac = drflac_open_with_metadata_private(drflac__on_read_stdio, drflac__on_seek_stdio, onMeta, drflac_container_unknown, (void*)pFile, pUserData, pAllocationCallbacks);
+ if (pFlac == NULL) {
+ fclose(pFile);
+ return pFlac;
+ }
+
+ return pFlac;
+}
+
+#ifndef DR_FLAC_NO_WCHAR
+DRFLAC_API drflac* drflac_open_file_with_metadata_w(const wchar_t* pFileName, drflac_meta_proc onMeta, void* pUserData, const drflac_allocation_callbacks* pAllocationCallbacks)
+{
+ drflac* pFlac;
+ FILE* pFile;
+
+ if (drflac_wfopen(&pFile, pFileName, L"rb", pAllocationCallbacks) != DRFLAC_SUCCESS) {
+ return NULL;
+ }
+
+ pFlac = drflac_open_with_metadata_private(drflac__on_read_stdio, drflac__on_seek_stdio, onMeta, drflac_container_unknown, (void*)pFile, pUserData, pAllocationCallbacks);
+ if (pFlac == NULL) {
+ fclose(pFile);
+ return pFlac;
+ }
+
+ return pFlac;
+}
+#endif
+#endif /* DR_FLAC_NO_STDIO */
+
+static size_t drflac__on_read_memory(void* pUserData, void* bufferOut, size_t bytesToRead)
+{
+ drflac__memory_stream* memoryStream = (drflac__memory_stream*)pUserData;
+ size_t bytesRemaining;
+
+ DRFLAC_ASSERT(memoryStream != NULL);
+ DRFLAC_ASSERT(memoryStream->dataSize >= memoryStream->currentReadPos);
+
+ bytesRemaining = memoryStream->dataSize - memoryStream->currentReadPos;
+ if (bytesToRead > bytesRemaining) {
+ bytesToRead = bytesRemaining;
+ }
+
+ if (bytesToRead > 0) {
+ DRFLAC_COPY_MEMORY(bufferOut, memoryStream->data + memoryStream->currentReadPos, bytesToRead);
+ memoryStream->currentReadPos += bytesToRead;
+ }
+
+ return bytesToRead;
+}
+
+static drflac_bool32 drflac__on_seek_memory(void* pUserData, int offset, drflac_seek_origin origin)
+{
+ drflac__memory_stream* memoryStream = (drflac__memory_stream*)pUserData;
+
+ DRFLAC_ASSERT(memoryStream != NULL);
+ DRFLAC_ASSERT(offset >= 0); /* <-- Never seek backwards. */
+
+ if (offset > (drflac_int64)memoryStream->dataSize) {
+ return DRFLAC_FALSE;
+ }
+
+ if (origin == drflac_seek_origin_current) {
+ if (memoryStream->currentReadPos + offset <= memoryStream->dataSize) {
+ memoryStream->currentReadPos += offset;
+ } else {
+ return DRFLAC_FALSE; /* Trying to seek too far forward. */
+ }
+ } else {
+ if ((drflac_uint32)offset <= memoryStream->dataSize) {
+ memoryStream->currentReadPos = offset;
+ } else {
+ return DRFLAC_FALSE; /* Trying to seek too far forward. */
+ }
+ }
+
+ return DRFLAC_TRUE;
+}
+
+DRFLAC_API drflac* drflac_open_memory(const void* pData, size_t dataSize, const drflac_allocation_callbacks* pAllocationCallbacks)
+{
+ drflac__memory_stream memoryStream;
+ drflac* pFlac;
+
+ memoryStream.data = (const drflac_uint8*)pData;
+ memoryStream.dataSize = dataSize;
+ memoryStream.currentReadPos = 0;
+ pFlac = drflac_open(drflac__on_read_memory, drflac__on_seek_memory, &memoryStream, pAllocationCallbacks);
+ if (pFlac == NULL) {
+ return NULL;
+ }
+
+ pFlac->memoryStream = memoryStream;
+
+ /* This is an awful hack... */
+#ifndef DR_FLAC_NO_OGG
+ if (pFlac->container == drflac_container_ogg)
+ {
+ drflac_oggbs* oggbs = (drflac_oggbs*)pFlac->_oggbs;
+ oggbs->pUserData = &pFlac->memoryStream;
+ }
+ else
+#endif
+ {
+ pFlac->bs.pUserData = &pFlac->memoryStream;
+ }
+
+ return pFlac;
+}
+
+DRFLAC_API drflac* drflac_open_memory_with_metadata(const void* pData, size_t dataSize, drflac_meta_proc onMeta, void* pUserData, const drflac_allocation_callbacks* pAllocationCallbacks)
+{
+ drflac__memory_stream memoryStream;
+ drflac* pFlac;
+
+ memoryStream.data = (const drflac_uint8*)pData;
+ memoryStream.dataSize = dataSize;
+ memoryStream.currentReadPos = 0;
+ pFlac = drflac_open_with_metadata_private(drflac__on_read_memory, drflac__on_seek_memory, onMeta, drflac_container_unknown, &memoryStream, pUserData, pAllocationCallbacks);
+ if (pFlac == NULL) {
+ return NULL;
+ }
+
+ pFlac->memoryStream = memoryStream;
+
+ /* This is an awful hack... */
+#ifndef DR_FLAC_NO_OGG
+ if (pFlac->container == drflac_container_ogg)
+ {
+ drflac_oggbs* oggbs = (drflac_oggbs*)pFlac->_oggbs;
+ oggbs->pUserData = &pFlac->memoryStream;
+ }
+ else
+#endif
+ {
+ pFlac->bs.pUserData = &pFlac->memoryStream;
+ }
+
+ return pFlac;
+}
+
+
+
+DRFLAC_API drflac* drflac_open(drflac_read_proc onRead, drflac_seek_proc onSeek, void* pUserData, const drflac_allocation_callbacks* pAllocationCallbacks)
+{
+ return drflac_open_with_metadata_private(onRead, onSeek, NULL, drflac_container_unknown, pUserData, pUserData, pAllocationCallbacks);
+}
+DRFLAC_API drflac* drflac_open_relaxed(drflac_read_proc onRead, drflac_seek_proc onSeek, drflac_container container, void* pUserData, const drflac_allocation_callbacks* pAllocationCallbacks)
+{
+ return drflac_open_with_metadata_private(onRead, onSeek, NULL, container, pUserData, pUserData, pAllocationCallbacks);
+}
+
+DRFLAC_API drflac* drflac_open_with_metadata(drflac_read_proc onRead, drflac_seek_proc onSeek, drflac_meta_proc onMeta, void* pUserData, const drflac_allocation_callbacks* pAllocationCallbacks)
+{
+ return drflac_open_with_metadata_private(onRead, onSeek, onMeta, drflac_container_unknown, pUserData, pUserData, pAllocationCallbacks);
+}
+DRFLAC_API drflac* drflac_open_with_metadata_relaxed(drflac_read_proc onRead, drflac_seek_proc onSeek, drflac_meta_proc onMeta, drflac_container container, void* pUserData, const drflac_allocation_callbacks* pAllocationCallbacks)
+{
+ return drflac_open_with_metadata_private(onRead, onSeek, onMeta, container, pUserData, pUserData, pAllocationCallbacks);
+}
+
+DRFLAC_API void drflac_close(drflac* pFlac)
+{
+ if (pFlac == NULL) {
+ return;
+ }
+
+#ifndef DR_FLAC_NO_STDIO
+ /*
+ If we opened the file with drflac_open_file() we will want to close the file handle. We can know whether or not drflac_open_file()
+ was used by looking at the callbacks.
+ */
+ if (pFlac->bs.onRead == drflac__on_read_stdio) {
+ fclose((FILE*)pFlac->bs.pUserData);
+ }
+
+#ifndef DR_FLAC_NO_OGG
+ /* Need to clean up Ogg streams a bit differently due to the way the bit streaming is chained. */
+ if (pFlac->container == drflac_container_ogg) {
+ drflac_oggbs* oggbs = (drflac_oggbs*)pFlac->_oggbs;
+ DRFLAC_ASSERT(pFlac->bs.onRead == drflac__on_read_ogg);
+
+ if (oggbs->onRead == drflac__on_read_stdio) {
+ fclose((FILE*)oggbs->pUserData);
+ }
+ }
+#endif
+#endif
+
+ drflac__free_from_callbacks(pFlac, &pFlac->allocationCallbacks);
+}
+
+
+#if 0
+static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_left_side__reference(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples)
+{
+ drflac_uint64 i;
+ for (i = 0; i < frameCount; ++i) {
+ drflac_uint32 left = (drflac_uint32)pInputSamples0[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+ drflac_uint32 side = (drflac_uint32)pInputSamples1[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+ drflac_uint32 right = left - side;
+
+ pOutputSamples[i*2+0] = (drflac_int32)left;
+ pOutputSamples[i*2+1] = (drflac_int32)right;
+ }
+}
+#endif
+
+static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_left_side__scalar(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples)
+{
+ drflac_uint64 i;
+ drflac_uint64 frameCount4 = frameCount >> 2;
+ const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0;
+ const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1;
+ drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+
+ for (i = 0; i < frameCount4; ++i) {
+ drflac_uint32 left0 = pInputSamples0U32[i*4+0] << shift0;
+ drflac_uint32 left1 = pInputSamples0U32[i*4+1] << shift0;
+ drflac_uint32 left2 = pInputSamples0U32[i*4+2] << shift0;
+ drflac_uint32 left3 = pInputSamples0U32[i*4+3] << shift0;
+
+ drflac_uint32 side0 = pInputSamples1U32[i*4+0] << shift1;
+ drflac_uint32 side1 = pInputSamples1U32[i*4+1] << shift1;
+ drflac_uint32 side2 = pInputSamples1U32[i*4+2] << shift1;
+ drflac_uint32 side3 = pInputSamples1U32[i*4+3] << shift1;
+
+ drflac_uint32 right0 = left0 - side0;
+ drflac_uint32 right1 = left1 - side1;
+ drflac_uint32 right2 = left2 - side2;
+ drflac_uint32 right3 = left3 - side3;
+
+ pOutputSamples[i*8+0] = (drflac_int32)left0;
+ pOutputSamples[i*8+1] = (drflac_int32)right0;
+ pOutputSamples[i*8+2] = (drflac_int32)left1;
+ pOutputSamples[i*8+3] = (drflac_int32)right1;
+ pOutputSamples[i*8+4] = (drflac_int32)left2;
+ pOutputSamples[i*8+5] = (drflac_int32)right2;
+ pOutputSamples[i*8+6] = (drflac_int32)left3;
+ pOutputSamples[i*8+7] = (drflac_int32)right3;
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ drflac_uint32 left = pInputSamples0U32[i] << shift0;
+ drflac_uint32 side = pInputSamples1U32[i] << shift1;
+ drflac_uint32 right = left - side;
+
+ pOutputSamples[i*2+0] = (drflac_int32)left;
+ pOutputSamples[i*2+1] = (drflac_int32)right;
+ }
+}
+
+#if defined(DRFLAC_SUPPORT_SSE2)
+static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_left_side__sse2(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples)
+{
+ drflac_uint64 i;
+ drflac_uint64 frameCount4 = frameCount >> 2;
+ const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0;
+ const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1;
+ drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+
+ DRFLAC_ASSERT(pFlac->bitsPerSample <= 24);
+
+ for (i = 0; i < frameCount4; ++i) {
+ __m128i left = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), shift0);
+ __m128i side = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), shift1);
+ __m128i right = _mm_sub_epi32(left, side);
+
+ _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 0), _mm_unpacklo_epi32(left, right));
+ _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 4), _mm_unpackhi_epi32(left, right));
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ drflac_uint32 left = pInputSamples0U32[i] << shift0;
+ drflac_uint32 side = pInputSamples1U32[i] << shift1;
+ drflac_uint32 right = left - side;
+
+ pOutputSamples[i*2+0] = (drflac_int32)left;
+ pOutputSamples[i*2+1] = (drflac_int32)right;
+ }
+}
+#endif
+
+#if defined(DRFLAC_SUPPORT_NEON)
+static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_left_side__neon(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples)
+{
+ drflac_uint64 i;
+ drflac_uint64 frameCount4 = frameCount >> 2;
+ const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0;
+ const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1;
+ drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+ int32x4_t shift0_4;
+ int32x4_t shift1_4;
+
+ DRFLAC_ASSERT(pFlac->bitsPerSample <= 24);
+
+ shift0_4 = vdupq_n_s32(shift0);
+ shift1_4 = vdupq_n_s32(shift1);
+
+ for (i = 0; i < frameCount4; ++i) {
+ uint32x4_t left;
+ uint32x4_t side;
+ uint32x4_t right;
+
+ left = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), shift0_4);
+ side = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), shift1_4);
+ right = vsubq_u32(left, side);
+
+ drflac__vst2q_u32((drflac_uint32*)pOutputSamples + i*8, vzipq_u32(left, right));
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ drflac_uint32 left = pInputSamples0U32[i] << shift0;
+ drflac_uint32 side = pInputSamples1U32[i] << shift1;
+ drflac_uint32 right = left - side;
+
+ pOutputSamples[i*2+0] = (drflac_int32)left;
+ pOutputSamples[i*2+1] = (drflac_int32)right;
+ }
+}
+#endif
+
+static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_left_side(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples)
+{
+#if defined(DRFLAC_SUPPORT_SSE2)
+ if (drflac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) {
+ drflac_read_pcm_frames_s32__decode_left_side__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+ } else
+#elif defined(DRFLAC_SUPPORT_NEON)
+ if (drflac__gIsNEONSupported && pFlac->bitsPerSample <= 24) {
+ drflac_read_pcm_frames_s32__decode_left_side__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+ } else
+#endif
+ {
+ /* Scalar fallback. */
+#if 0
+ drflac_read_pcm_frames_s32__decode_left_side__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#else
+ drflac_read_pcm_frames_s32__decode_left_side__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#endif
+ }
+}
+
+
+#if 0
+static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_right_side__reference(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples)
+{
+ drflac_uint64 i;
+ for (i = 0; i < frameCount; ++i) {
+ drflac_uint32 side = (drflac_uint32)pInputSamples0[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+ drflac_uint32 right = (drflac_uint32)pInputSamples1[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+ drflac_uint32 left = right + side;
+
+ pOutputSamples[i*2+0] = (drflac_int32)left;
+ pOutputSamples[i*2+1] = (drflac_int32)right;
+ }
+}
+#endif
+
+static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_right_side__scalar(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples)
+{
+ drflac_uint64 i;
+ drflac_uint64 frameCount4 = frameCount >> 2;
+ const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0;
+ const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1;
+ drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+
+ for (i = 0; i < frameCount4; ++i) {
+ drflac_uint32 side0 = pInputSamples0U32[i*4+0] << shift0;
+ drflac_uint32 side1 = pInputSamples0U32[i*4+1] << shift0;
+ drflac_uint32 side2 = pInputSamples0U32[i*4+2] << shift0;
+ drflac_uint32 side3 = pInputSamples0U32[i*4+3] << shift0;
+
+ drflac_uint32 right0 = pInputSamples1U32[i*4+0] << shift1;
+ drflac_uint32 right1 = pInputSamples1U32[i*4+1] << shift1;
+ drflac_uint32 right2 = pInputSamples1U32[i*4+2] << shift1;
+ drflac_uint32 right3 = pInputSamples1U32[i*4+3] << shift1;
+
+ drflac_uint32 left0 = right0 + side0;
+ drflac_uint32 left1 = right1 + side1;
+ drflac_uint32 left2 = right2 + side2;
+ drflac_uint32 left3 = right3 + side3;
+
+ pOutputSamples[i*8+0] = (drflac_int32)left0;
+ pOutputSamples[i*8+1] = (drflac_int32)right0;
+ pOutputSamples[i*8+2] = (drflac_int32)left1;
+ pOutputSamples[i*8+3] = (drflac_int32)right1;
+ pOutputSamples[i*8+4] = (drflac_int32)left2;
+ pOutputSamples[i*8+5] = (drflac_int32)right2;
+ pOutputSamples[i*8+6] = (drflac_int32)left3;
+ pOutputSamples[i*8+7] = (drflac_int32)right3;
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ drflac_uint32 side = pInputSamples0U32[i] << shift0;
+ drflac_uint32 right = pInputSamples1U32[i] << shift1;
+ drflac_uint32 left = right + side;
+
+ pOutputSamples[i*2+0] = (drflac_int32)left;
+ pOutputSamples[i*2+1] = (drflac_int32)right;
+ }
+}
+
+#if defined(DRFLAC_SUPPORT_SSE2)
+static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_right_side__sse2(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples)
+{
+ drflac_uint64 i;
+ drflac_uint64 frameCount4 = frameCount >> 2;
+ const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0;
+ const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1;
+ drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+
+ DRFLAC_ASSERT(pFlac->bitsPerSample <= 24);
+
+ for (i = 0; i < frameCount4; ++i) {
+ __m128i side = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), shift0);
+ __m128i right = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), shift1);
+ __m128i left = _mm_add_epi32(right, side);
+
+ _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 0), _mm_unpacklo_epi32(left, right));
+ _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 4), _mm_unpackhi_epi32(left, right));
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ drflac_uint32 side = pInputSamples0U32[i] << shift0;
+ drflac_uint32 right = pInputSamples1U32[i] << shift1;
+ drflac_uint32 left = right + side;
+
+ pOutputSamples[i*2+0] = (drflac_int32)left;
+ pOutputSamples[i*2+1] = (drflac_int32)right;
+ }
+}
+#endif
+
+#if defined(DRFLAC_SUPPORT_NEON)
+static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_right_side__neon(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples)
+{
+ drflac_uint64 i;
+ drflac_uint64 frameCount4 = frameCount >> 2;
+ const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0;
+ const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1;
+ drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+ int32x4_t shift0_4;
+ int32x4_t shift1_4;
+
+ DRFLAC_ASSERT(pFlac->bitsPerSample <= 24);
+
+ shift0_4 = vdupq_n_s32(shift0);
+ shift1_4 = vdupq_n_s32(shift1);
+
+ for (i = 0; i < frameCount4; ++i) {
+ uint32x4_t side;
+ uint32x4_t right;
+ uint32x4_t left;
+
+ side = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), shift0_4);
+ right = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), shift1_4);
+ left = vaddq_u32(right, side);
+
+ drflac__vst2q_u32((drflac_uint32*)pOutputSamples + i*8, vzipq_u32(left, right));
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ drflac_uint32 side = pInputSamples0U32[i] << shift0;
+ drflac_uint32 right = pInputSamples1U32[i] << shift1;
+ drflac_uint32 left = right + side;
+
+ pOutputSamples[i*2+0] = (drflac_int32)left;
+ pOutputSamples[i*2+1] = (drflac_int32)right;
+ }
+}
+#endif
+
+static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_right_side(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples)
+{
+#if defined(DRFLAC_SUPPORT_SSE2)
+ if (drflac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) {
+ drflac_read_pcm_frames_s32__decode_right_side__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+ } else
+#elif defined(DRFLAC_SUPPORT_NEON)
+ if (drflac__gIsNEONSupported && pFlac->bitsPerSample <= 24) {
+ drflac_read_pcm_frames_s32__decode_right_side__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+ } else
+#endif
+ {
+ /* Scalar fallback. */
+#if 0
+ drflac_read_pcm_frames_s32__decode_right_side__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#else
+ drflac_read_pcm_frames_s32__decode_right_side__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#endif
+ }
+}
+
+
+#if 0
+static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_mid_side__reference(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples)
+{
+ for (drflac_uint64 i = 0; i < frameCount; ++i) {
+ drflac_uint32 mid = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+
+ mid = (mid << 1) | (side & 0x01);
+
+ pOutputSamples[i*2+0] = (drflac_int32)((drflac_uint32)((drflac_int32)(mid + side) >> 1) << unusedBitsPerSample);
+ pOutputSamples[i*2+1] = (drflac_int32)((drflac_uint32)((drflac_int32)(mid - side) >> 1) << unusedBitsPerSample);
+ }
+}
+#endif
+
+static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_mid_side__scalar(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples)
+{
+ drflac_uint64 i;
+ drflac_uint64 frameCount4 = frameCount >> 2;
+ const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0;
+ const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1;
+ drflac_int32 shift = unusedBitsPerSample;
+
+ if (shift > 0) {
+ shift -= 1;
+ for (i = 0; i < frameCount4; ++i) {
+ drflac_uint32 temp0L;
+ drflac_uint32 temp1L;
+ drflac_uint32 temp2L;
+ drflac_uint32 temp3L;
+ drflac_uint32 temp0R;
+ drflac_uint32 temp1R;
+ drflac_uint32 temp2R;
+ drflac_uint32 temp3R;
+
+ drflac_uint32 mid0 = pInputSamples0U32[i*4+0] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 mid1 = pInputSamples0U32[i*4+1] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 mid2 = pInputSamples0U32[i*4+2] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 mid3 = pInputSamples0U32[i*4+3] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+
+ drflac_uint32 side0 = pInputSamples1U32[i*4+0] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+ drflac_uint32 side1 = pInputSamples1U32[i*4+1] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+ drflac_uint32 side2 = pInputSamples1U32[i*4+2] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+ drflac_uint32 side3 = pInputSamples1U32[i*4+3] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+
+ mid0 = (mid0 << 1) | (side0 & 0x01);
+ mid1 = (mid1 << 1) | (side1 & 0x01);
+ mid2 = (mid2 << 1) | (side2 & 0x01);
+ mid3 = (mid3 << 1) | (side3 & 0x01);
+
+ temp0L = (mid0 + side0) << shift;
+ temp1L = (mid1 + side1) << shift;
+ temp2L = (mid2 + side2) << shift;
+ temp3L = (mid3 + side3) << shift;
+
+ temp0R = (mid0 - side0) << shift;
+ temp1R = (mid1 - side1) << shift;
+ temp2R = (mid2 - side2) << shift;
+ temp3R = (mid3 - side3) << shift;
+
+ pOutputSamples[i*8+0] = (drflac_int32)temp0L;
+ pOutputSamples[i*8+1] = (drflac_int32)temp0R;
+ pOutputSamples[i*8+2] = (drflac_int32)temp1L;
+ pOutputSamples[i*8+3] = (drflac_int32)temp1R;
+ pOutputSamples[i*8+4] = (drflac_int32)temp2L;
+ pOutputSamples[i*8+5] = (drflac_int32)temp2R;
+ pOutputSamples[i*8+6] = (drflac_int32)temp3L;
+ pOutputSamples[i*8+7] = (drflac_int32)temp3R;
+ }
+ } else {
+ for (i = 0; i < frameCount4; ++i) {
+ drflac_uint32 temp0L;
+ drflac_uint32 temp1L;
+ drflac_uint32 temp2L;
+ drflac_uint32 temp3L;
+ drflac_uint32 temp0R;
+ drflac_uint32 temp1R;
+ drflac_uint32 temp2R;
+ drflac_uint32 temp3R;
+
+ drflac_uint32 mid0 = pInputSamples0U32[i*4+0] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 mid1 = pInputSamples0U32[i*4+1] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 mid2 = pInputSamples0U32[i*4+2] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 mid3 = pInputSamples0U32[i*4+3] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+
+ drflac_uint32 side0 = pInputSamples1U32[i*4+0] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+ drflac_uint32 side1 = pInputSamples1U32[i*4+1] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+ drflac_uint32 side2 = pInputSamples1U32[i*4+2] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+ drflac_uint32 side3 = pInputSamples1U32[i*4+3] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+
+ mid0 = (mid0 << 1) | (side0 & 0x01);
+ mid1 = (mid1 << 1) | (side1 & 0x01);
+ mid2 = (mid2 << 1) | (side2 & 0x01);
+ mid3 = (mid3 << 1) | (side3 & 0x01);
+
+ temp0L = (drflac_uint32)((drflac_int32)(mid0 + side0) >> 1);
+ temp1L = (drflac_uint32)((drflac_int32)(mid1 + side1) >> 1);
+ temp2L = (drflac_uint32)((drflac_int32)(mid2 + side2) >> 1);
+ temp3L = (drflac_uint32)((drflac_int32)(mid3 + side3) >> 1);
+
+ temp0R = (drflac_uint32)((drflac_int32)(mid0 - side0) >> 1);
+ temp1R = (drflac_uint32)((drflac_int32)(mid1 - side1) >> 1);
+ temp2R = (drflac_uint32)((drflac_int32)(mid2 - side2) >> 1);
+ temp3R = (drflac_uint32)((drflac_int32)(mid3 - side3) >> 1);
+
+ pOutputSamples[i*8+0] = (drflac_int32)temp0L;
+ pOutputSamples[i*8+1] = (drflac_int32)temp0R;
+ pOutputSamples[i*8+2] = (drflac_int32)temp1L;
+ pOutputSamples[i*8+3] = (drflac_int32)temp1R;
+ pOutputSamples[i*8+4] = (drflac_int32)temp2L;
+ pOutputSamples[i*8+5] = (drflac_int32)temp2R;
+ pOutputSamples[i*8+6] = (drflac_int32)temp3L;
+ pOutputSamples[i*8+7] = (drflac_int32)temp3R;
+ }
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ drflac_uint32 mid = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+
+ mid = (mid << 1) | (side & 0x01);
+
+ pOutputSamples[i*2+0] = (drflac_int32)((drflac_uint32)((drflac_int32)(mid + side) >> 1) << unusedBitsPerSample);
+ pOutputSamples[i*2+1] = (drflac_int32)((drflac_uint32)((drflac_int32)(mid - side) >> 1) << unusedBitsPerSample);
+ }
+}
+
+#if defined(DRFLAC_SUPPORT_SSE2)
+static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_mid_side__sse2(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples)
+{
+ drflac_uint64 i;
+ drflac_uint64 frameCount4 = frameCount >> 2;
+ const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0;
+ const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1;
+ drflac_int32 shift = unusedBitsPerSample;
+
+ DRFLAC_ASSERT(pFlac->bitsPerSample <= 24);
+
+ if (shift == 0) {
+ for (i = 0; i < frameCount4; ++i) {
+ __m128i mid;
+ __m128i side;
+ __m128i left;
+ __m128i right;
+
+ mid = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+ side = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+
+ mid = _mm_or_si128(_mm_slli_epi32(mid, 1), _mm_and_si128(side, _mm_set1_epi32(0x01)));
+
+ left = _mm_srai_epi32(_mm_add_epi32(mid, side), 1);
+ right = _mm_srai_epi32(_mm_sub_epi32(mid, side), 1);
+
+ _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 0), _mm_unpacklo_epi32(left, right));
+ _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 4), _mm_unpackhi_epi32(left, right));
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ drflac_uint32 mid = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+
+ mid = (mid << 1) | (side & 0x01);
+
+ pOutputSamples[i*2+0] = (drflac_int32)(mid + side) >> 1;
+ pOutputSamples[i*2+1] = (drflac_int32)(mid - side) >> 1;
+ }
+ } else {
+ shift -= 1;
+ for (i = 0; i < frameCount4; ++i) {
+ __m128i mid;
+ __m128i side;
+ __m128i left;
+ __m128i right;
+
+ mid = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+ side = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+
+ mid = _mm_or_si128(_mm_slli_epi32(mid, 1), _mm_and_si128(side, _mm_set1_epi32(0x01)));
+
+ left = _mm_slli_epi32(_mm_add_epi32(mid, side), shift);
+ right = _mm_slli_epi32(_mm_sub_epi32(mid, side), shift);
+
+ _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 0), _mm_unpacklo_epi32(left, right));
+ _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 4), _mm_unpackhi_epi32(left, right));
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ drflac_uint32 mid = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+
+ mid = (mid << 1) | (side & 0x01);
+
+ pOutputSamples[i*2+0] = (drflac_int32)((mid + side) << shift);
+ pOutputSamples[i*2+1] = (drflac_int32)((mid - side) << shift);
+ }
+ }
+}
+#endif
+
+#if defined(DRFLAC_SUPPORT_NEON)
+static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_mid_side__neon(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples)
+{
+ drflac_uint64 i;
+ drflac_uint64 frameCount4 = frameCount >> 2;
+ const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0;
+ const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1;
+ drflac_int32 shift = unusedBitsPerSample;
+ int32x4_t wbpsShift0_4; /* wbps = Wasted Bits Per Sample */
+ int32x4_t wbpsShift1_4; /* wbps = Wasted Bits Per Sample */
+ uint32x4_t one4;
+
+ DRFLAC_ASSERT(pFlac->bitsPerSample <= 24);
+
+ wbpsShift0_4 = vdupq_n_s32(pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+ wbpsShift1_4 = vdupq_n_s32(pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+ one4 = vdupq_n_u32(1);
+
+ if (shift == 0) {
+ for (i = 0; i < frameCount4; ++i) {
+ uint32x4_t mid;
+ uint32x4_t side;
+ int32x4_t left;
+ int32x4_t right;
+
+ mid = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), wbpsShift0_4);
+ side = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), wbpsShift1_4);
+
+ mid = vorrq_u32(vshlq_n_u32(mid, 1), vandq_u32(side, one4));
+
+ left = vshrq_n_s32(vreinterpretq_s32_u32(vaddq_u32(mid, side)), 1);
+ right = vshrq_n_s32(vreinterpretq_s32_u32(vsubq_u32(mid, side)), 1);
+
+ drflac__vst2q_s32(pOutputSamples + i*8, vzipq_s32(left, right));
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ drflac_uint32 mid = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+
+ mid = (mid << 1) | (side & 0x01);
+
+ pOutputSamples[i*2+0] = (drflac_int32)(mid + side) >> 1;
+ pOutputSamples[i*2+1] = (drflac_int32)(mid - side) >> 1;
+ }
+ } else {
+ int32x4_t shift4;
+
+ shift -= 1;
+ shift4 = vdupq_n_s32(shift);
+
+ for (i = 0; i < frameCount4; ++i) {
+ uint32x4_t mid;
+ uint32x4_t side;
+ int32x4_t left;
+ int32x4_t right;
+
+ mid = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), wbpsShift0_4);
+ side = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), wbpsShift1_4);
+
+ mid = vorrq_u32(vshlq_n_u32(mid, 1), vandq_u32(side, one4));
+
+ left = vreinterpretq_s32_u32(vshlq_u32(vaddq_u32(mid, side), shift4));
+ right = vreinterpretq_s32_u32(vshlq_u32(vsubq_u32(mid, side), shift4));
+
+ drflac__vst2q_s32(pOutputSamples + i*8, vzipq_s32(left, right));
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ drflac_uint32 mid = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+
+ mid = (mid << 1) | (side & 0x01);
+
+ pOutputSamples[i*2+0] = (drflac_int32)((mid + side) << shift);
+ pOutputSamples[i*2+1] = (drflac_int32)((mid - side) << shift);
+ }
+ }
+}
+#endif
+
+static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_mid_side(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples)
+{
+#if defined(DRFLAC_SUPPORT_SSE2)
+ if (drflac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) {
+ drflac_read_pcm_frames_s32__decode_mid_side__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+ } else
+#elif defined(DRFLAC_SUPPORT_NEON)
+ if (drflac__gIsNEONSupported && pFlac->bitsPerSample <= 24) {
+ drflac_read_pcm_frames_s32__decode_mid_side__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+ } else
+#endif
+ {
+ /* Scalar fallback. */
+#if 0
+ drflac_read_pcm_frames_s32__decode_mid_side__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#else
+ drflac_read_pcm_frames_s32__decode_mid_side__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#endif
+ }
+}
+
+
+#if 0
+static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_independent_stereo__reference(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples)
+{
+ for (drflac_uint64 i = 0; i < frameCount; ++i) {
+ pOutputSamples[i*2+0] = (drflac_int32)((drflac_uint32)pInputSamples0[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample));
+ pOutputSamples[i*2+1] = (drflac_int32)((drflac_uint32)pInputSamples1[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample));
+ }
+}
+#endif
+
+static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_independent_stereo__scalar(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples)
+{
+ drflac_uint64 i;
+ drflac_uint64 frameCount4 = frameCount >> 2;
+ const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0;
+ const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1;
+ drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+
+ for (i = 0; i < frameCount4; ++i) {
+ drflac_uint32 tempL0 = pInputSamples0U32[i*4+0] << shift0;
+ drflac_uint32 tempL1 = pInputSamples0U32[i*4+1] << shift0;
+ drflac_uint32 tempL2 = pInputSamples0U32[i*4+2] << shift0;
+ drflac_uint32 tempL3 = pInputSamples0U32[i*4+3] << shift0;
+
+ drflac_uint32 tempR0 = pInputSamples1U32[i*4+0] << shift1;
+ drflac_uint32 tempR1 = pInputSamples1U32[i*4+1] << shift1;
+ drflac_uint32 tempR2 = pInputSamples1U32[i*4+2] << shift1;
+ drflac_uint32 tempR3 = pInputSamples1U32[i*4+3] << shift1;
+
+ pOutputSamples[i*8+0] = (drflac_int32)tempL0;
+ pOutputSamples[i*8+1] = (drflac_int32)tempR0;
+ pOutputSamples[i*8+2] = (drflac_int32)tempL1;
+ pOutputSamples[i*8+3] = (drflac_int32)tempR1;
+ pOutputSamples[i*8+4] = (drflac_int32)tempL2;
+ pOutputSamples[i*8+5] = (drflac_int32)tempR2;
+ pOutputSamples[i*8+6] = (drflac_int32)tempL3;
+ pOutputSamples[i*8+7] = (drflac_int32)tempR3;
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ pOutputSamples[i*2+0] = (drflac_int32)(pInputSamples0U32[i] << shift0);
+ pOutputSamples[i*2+1] = (drflac_int32)(pInputSamples1U32[i] << shift1);
+ }
+}
+
+#if defined(DRFLAC_SUPPORT_SSE2)
+static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_independent_stereo__sse2(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples)
+{
+ drflac_uint64 i;
+ drflac_uint64 frameCount4 = frameCount >> 2;
+ const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0;
+ const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1;
+ drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+
+ for (i = 0; i < frameCount4; ++i) {
+ __m128i left = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), shift0);
+ __m128i right = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), shift1);
+
+ _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 0), _mm_unpacklo_epi32(left, right));
+ _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 4), _mm_unpackhi_epi32(left, right));
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ pOutputSamples[i*2+0] = (drflac_int32)(pInputSamples0U32[i] << shift0);
+ pOutputSamples[i*2+1] = (drflac_int32)(pInputSamples1U32[i] << shift1);
+ }
+}
+#endif
+
+#if defined(DRFLAC_SUPPORT_NEON)
+static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_independent_stereo__neon(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples)
+{
+ drflac_uint64 i;
+ drflac_uint64 frameCount4 = frameCount >> 2;
+ const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0;
+ const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1;
+ drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+
+ int32x4_t shift4_0 = vdupq_n_s32(shift0);
+ int32x4_t shift4_1 = vdupq_n_s32(shift1);
+
+ for (i = 0; i < frameCount4; ++i) {
+ int32x4_t left;
+ int32x4_t right;
+
+ left = vreinterpretq_s32_u32(vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), shift4_0));
+ right = vreinterpretq_s32_u32(vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), shift4_1));
+
+ drflac__vst2q_s32(pOutputSamples + i*8, vzipq_s32(left, right));
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ pOutputSamples[i*2+0] = (drflac_int32)(pInputSamples0U32[i] << shift0);
+ pOutputSamples[i*2+1] = (drflac_int32)(pInputSamples1U32[i] << shift1);
+ }
+}
+#endif
+
+static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_independent_stereo(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples)
+{
+#if defined(DRFLAC_SUPPORT_SSE2)
+ if (drflac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) {
+ drflac_read_pcm_frames_s32__decode_independent_stereo__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+ } else
+#elif defined(DRFLAC_SUPPORT_NEON)
+ if (drflac__gIsNEONSupported && pFlac->bitsPerSample <= 24) {
+ drflac_read_pcm_frames_s32__decode_independent_stereo__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+ } else
+#endif
+ {
+ /* Scalar fallback. */
+#if 0
+ drflac_read_pcm_frames_s32__decode_independent_stereo__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#else
+ drflac_read_pcm_frames_s32__decode_independent_stereo__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#endif
+ }
+}
+
+
+DRFLAC_API drflac_uint64 drflac_read_pcm_frames_s32(drflac* pFlac, drflac_uint64 framesToRead, drflac_int32* pBufferOut)
+{
+ drflac_uint64 framesRead;
+ drflac_uint32 unusedBitsPerSample;
+
+ if (pFlac == NULL || framesToRead == 0) {
+ return 0;
+ }
+
+ if (pBufferOut == NULL) {
+ return drflac__seek_forward_by_pcm_frames(pFlac, framesToRead);
+ }
+
+ DRFLAC_ASSERT(pFlac->bitsPerSample <= 32);
+ unusedBitsPerSample = 32 - pFlac->bitsPerSample;
+
+ framesRead = 0;
+ while (framesToRead > 0) {
+ /* If we've run out of samples in this frame, go to the next. */
+ if (pFlac->currentFLACFrame.pcmFramesRemaining == 0) {
+ if (!drflac__read_and_decode_next_flac_frame(pFlac)) {
+ break; /* Couldn't read the next frame, so just break from the loop and return. */
+ }
+ } else {
+ unsigned int channelCount = drflac__get_channel_count_from_channel_assignment(pFlac->currentFLACFrame.header.channelAssignment);
+ drflac_uint64 iFirstPCMFrame = pFlac->currentFLACFrame.header.blockSizeInPCMFrames - pFlac->currentFLACFrame.pcmFramesRemaining;
+ drflac_uint64 frameCountThisIteration = framesToRead;
+
+ if (frameCountThisIteration > pFlac->currentFLACFrame.pcmFramesRemaining) {
+ frameCountThisIteration = pFlac->currentFLACFrame.pcmFramesRemaining;
+ }
+
+ if (channelCount == 2) {
+ const drflac_int32* pDecodedSamples0 = pFlac->currentFLACFrame.subframes[0].pSamplesS32 + iFirstPCMFrame;
+ const drflac_int32* pDecodedSamples1 = pFlac->currentFLACFrame.subframes[1].pSamplesS32 + iFirstPCMFrame;
+
+ switch (pFlac->currentFLACFrame.header.channelAssignment)
+ {
+ case DRFLAC_CHANNEL_ASSIGNMENT_LEFT_SIDE:
+ {
+ drflac_read_pcm_frames_s32__decode_left_side(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut);
+ } break;
+
+ case DRFLAC_CHANNEL_ASSIGNMENT_RIGHT_SIDE:
+ {
+ drflac_read_pcm_frames_s32__decode_right_side(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut);
+ } break;
+
+ case DRFLAC_CHANNEL_ASSIGNMENT_MID_SIDE:
+ {
+ drflac_read_pcm_frames_s32__decode_mid_side(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut);
+ } break;
+
+ case DRFLAC_CHANNEL_ASSIGNMENT_INDEPENDENT:
+ default:
+ {
+ drflac_read_pcm_frames_s32__decode_independent_stereo(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut);
+ } break;
+ }
+ } else {
+ /* Generic interleaving. */
+ drflac_uint64 i;
+ for (i = 0; i < frameCountThisIteration; ++i) {
+ unsigned int j;
+ for (j = 0; j < channelCount; ++j) {
+ pBufferOut[(i*channelCount)+j] = (drflac_int32)((drflac_uint32)(pFlac->currentFLACFrame.subframes[j].pSamplesS32[iFirstPCMFrame + i]) << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[j].wastedBitsPerSample));
+ }
+ }
+ }
+
+ framesRead += frameCountThisIteration;
+ pBufferOut += frameCountThisIteration * channelCount;
+ framesToRead -= frameCountThisIteration;
+ pFlac->currentPCMFrame += frameCountThisIteration;
+ pFlac->currentFLACFrame.pcmFramesRemaining -= (drflac_uint32)frameCountThisIteration;
+ }
+ }
+
+ return framesRead;
+}
+
+
+#if 0
+static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_left_side__reference(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples)
+{
+ drflac_uint64 i;
+ for (i = 0; i < frameCount; ++i) {
+ drflac_uint32 left = (drflac_uint32)pInputSamples0[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+ drflac_uint32 side = (drflac_uint32)pInputSamples1[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+ drflac_uint32 right = left - side;
+
+ left >>= 16;
+ right >>= 16;
+
+ pOutputSamples[i*2+0] = (drflac_int16)left;
+ pOutputSamples[i*2+1] = (drflac_int16)right;
+ }
+}
+#endif
+
+static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_left_side__scalar(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples)
+{
+ drflac_uint64 i;
+ drflac_uint64 frameCount4 = frameCount >> 2;
+ const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0;
+ const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1;
+ drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+
+ for (i = 0; i < frameCount4; ++i) {
+ drflac_uint32 left0 = pInputSamples0U32[i*4+0] << shift0;
+ drflac_uint32 left1 = pInputSamples0U32[i*4+1] << shift0;
+ drflac_uint32 left2 = pInputSamples0U32[i*4+2] << shift0;
+ drflac_uint32 left3 = pInputSamples0U32[i*4+3] << shift0;
+
+ drflac_uint32 side0 = pInputSamples1U32[i*4+0] << shift1;
+ drflac_uint32 side1 = pInputSamples1U32[i*4+1] << shift1;
+ drflac_uint32 side2 = pInputSamples1U32[i*4+2] << shift1;
+ drflac_uint32 side3 = pInputSamples1U32[i*4+3] << shift1;
+
+ drflac_uint32 right0 = left0 - side0;
+ drflac_uint32 right1 = left1 - side1;
+ drflac_uint32 right2 = left2 - side2;
+ drflac_uint32 right3 = left3 - side3;
+
+ left0 >>= 16;
+ left1 >>= 16;
+ left2 >>= 16;
+ left3 >>= 16;
+
+ right0 >>= 16;
+ right1 >>= 16;
+ right2 >>= 16;
+ right3 >>= 16;
+
+ pOutputSamples[i*8+0] = (drflac_int16)left0;
+ pOutputSamples[i*8+1] = (drflac_int16)right0;
+ pOutputSamples[i*8+2] = (drflac_int16)left1;
+ pOutputSamples[i*8+3] = (drflac_int16)right1;
+ pOutputSamples[i*8+4] = (drflac_int16)left2;
+ pOutputSamples[i*8+5] = (drflac_int16)right2;
+ pOutputSamples[i*8+6] = (drflac_int16)left3;
+ pOutputSamples[i*8+7] = (drflac_int16)right3;
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ drflac_uint32 left = pInputSamples0U32[i] << shift0;
+ drflac_uint32 side = pInputSamples1U32[i] << shift1;
+ drflac_uint32 right = left - side;
+
+ left >>= 16;
+ right >>= 16;
+
+ pOutputSamples[i*2+0] = (drflac_int16)left;
+ pOutputSamples[i*2+1] = (drflac_int16)right;
+ }
+}
+
+#if defined(DRFLAC_SUPPORT_SSE2)
+static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_left_side__sse2(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples)
+{
+ drflac_uint64 i;
+ drflac_uint64 frameCount4 = frameCount >> 2;
+ const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0;
+ const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1;
+ drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+
+ DRFLAC_ASSERT(pFlac->bitsPerSample <= 24);
+
+ for (i = 0; i < frameCount4; ++i) {
+ __m128i left = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), shift0);
+ __m128i side = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), shift1);
+ __m128i right = _mm_sub_epi32(left, side);
+
+ left = _mm_srai_epi32(left, 16);
+ right = _mm_srai_epi32(right, 16);
+
+ _mm_storeu_si128((__m128i*)(pOutputSamples + i*8), drflac__mm_packs_interleaved_epi32(left, right));
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ drflac_uint32 left = pInputSamples0U32[i] << shift0;
+ drflac_uint32 side = pInputSamples1U32[i] << shift1;
+ drflac_uint32 right = left - side;
+
+ left >>= 16;
+ right >>= 16;
+
+ pOutputSamples[i*2+0] = (drflac_int16)left;
+ pOutputSamples[i*2+1] = (drflac_int16)right;
+ }
+}
+#endif
+
+#if defined(DRFLAC_SUPPORT_NEON)
+static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_left_side__neon(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples)
+{
+ drflac_uint64 i;
+ drflac_uint64 frameCount4 = frameCount >> 2;
+ const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0;
+ const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1;
+ drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+ int32x4_t shift0_4;
+ int32x4_t shift1_4;
+
+ DRFLAC_ASSERT(pFlac->bitsPerSample <= 24);
+
+ shift0_4 = vdupq_n_s32(shift0);
+ shift1_4 = vdupq_n_s32(shift1);
+
+ for (i = 0; i < frameCount4; ++i) {
+ uint32x4_t left;
+ uint32x4_t side;
+ uint32x4_t right;
+
+ left = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), shift0_4);
+ side = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), shift1_4);
+ right = vsubq_u32(left, side);
+
+ left = vshrq_n_u32(left, 16);
+ right = vshrq_n_u32(right, 16);
+
+ drflac__vst2q_u16((drflac_uint16*)pOutputSamples + i*8, vzip_u16(vmovn_u32(left), vmovn_u32(right)));
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ drflac_uint32 left = pInputSamples0U32[i] << shift0;
+ drflac_uint32 side = pInputSamples1U32[i] << shift1;
+ drflac_uint32 right = left - side;
+
+ left >>= 16;
+ right >>= 16;
+
+ pOutputSamples[i*2+0] = (drflac_int16)left;
+ pOutputSamples[i*2+1] = (drflac_int16)right;
+ }
+}
+#endif
+
+static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_left_side(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples)
+{
+#if defined(DRFLAC_SUPPORT_SSE2)
+ if (drflac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) {
+ drflac_read_pcm_frames_s16__decode_left_side__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+ } else
+#elif defined(DRFLAC_SUPPORT_NEON)
+ if (drflac__gIsNEONSupported && pFlac->bitsPerSample <= 24) {
+ drflac_read_pcm_frames_s16__decode_left_side__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+ } else
+#endif
+ {
+ /* Scalar fallback. */
+#if 0
+ drflac_read_pcm_frames_s16__decode_left_side__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#else
+ drflac_read_pcm_frames_s16__decode_left_side__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#endif
+ }
+}
+
+
+#if 0
+static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_right_side__reference(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples)
+{
+ drflac_uint64 i;
+ for (i = 0; i < frameCount; ++i) {
+ drflac_uint32 side = (drflac_uint32)pInputSamples0[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+ drflac_uint32 right = (drflac_uint32)pInputSamples1[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+ drflac_uint32 left = right + side;
+
+ left >>= 16;
+ right >>= 16;
+
+ pOutputSamples[i*2+0] = (drflac_int16)left;
+ pOutputSamples[i*2+1] = (drflac_int16)right;
+ }
+}
+#endif
+
+static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_right_side__scalar(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples)
+{
+ drflac_uint64 i;
+ drflac_uint64 frameCount4 = frameCount >> 2;
+ const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0;
+ const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1;
+ drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+
+ for (i = 0; i < frameCount4; ++i) {
+ drflac_uint32 side0 = pInputSamples0U32[i*4+0] << shift0;
+ drflac_uint32 side1 = pInputSamples0U32[i*4+1] << shift0;
+ drflac_uint32 side2 = pInputSamples0U32[i*4+2] << shift0;
+ drflac_uint32 side3 = pInputSamples0U32[i*4+3] << shift0;
+
+ drflac_uint32 right0 = pInputSamples1U32[i*4+0] << shift1;
+ drflac_uint32 right1 = pInputSamples1U32[i*4+1] << shift1;
+ drflac_uint32 right2 = pInputSamples1U32[i*4+2] << shift1;
+ drflac_uint32 right3 = pInputSamples1U32[i*4+3] << shift1;
+
+ drflac_uint32 left0 = right0 + side0;
+ drflac_uint32 left1 = right1 + side1;
+ drflac_uint32 left2 = right2 + side2;
+ drflac_uint32 left3 = right3 + side3;
+
+ left0 >>= 16;
+ left1 >>= 16;
+ left2 >>= 16;
+ left3 >>= 16;
+
+ right0 >>= 16;
+ right1 >>= 16;
+ right2 >>= 16;
+ right3 >>= 16;
+
+ pOutputSamples[i*8+0] = (drflac_int16)left0;
+ pOutputSamples[i*8+1] = (drflac_int16)right0;
+ pOutputSamples[i*8+2] = (drflac_int16)left1;
+ pOutputSamples[i*8+3] = (drflac_int16)right1;
+ pOutputSamples[i*8+4] = (drflac_int16)left2;
+ pOutputSamples[i*8+5] = (drflac_int16)right2;
+ pOutputSamples[i*8+6] = (drflac_int16)left3;
+ pOutputSamples[i*8+7] = (drflac_int16)right3;
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ drflac_uint32 side = pInputSamples0U32[i] << shift0;
+ drflac_uint32 right = pInputSamples1U32[i] << shift1;
+ drflac_uint32 left = right + side;
+
+ left >>= 16;
+ right >>= 16;
+
+ pOutputSamples[i*2+0] = (drflac_int16)left;
+ pOutputSamples[i*2+1] = (drflac_int16)right;
+ }
+}
+
+#if defined(DRFLAC_SUPPORT_SSE2)
+static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_right_side__sse2(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples)
+{
+ drflac_uint64 i;
+ drflac_uint64 frameCount4 = frameCount >> 2;
+ const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0;
+ const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1;
+ drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+
+ DRFLAC_ASSERT(pFlac->bitsPerSample <= 24);
+
+ for (i = 0; i < frameCount4; ++i) {
+ __m128i side = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), shift0);
+ __m128i right = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), shift1);
+ __m128i left = _mm_add_epi32(right, side);
+
+ left = _mm_srai_epi32(left, 16);
+ right = _mm_srai_epi32(right, 16);
+
+ _mm_storeu_si128((__m128i*)(pOutputSamples + i*8), drflac__mm_packs_interleaved_epi32(left, right));
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ drflac_uint32 side = pInputSamples0U32[i] << shift0;
+ drflac_uint32 right = pInputSamples1U32[i] << shift1;
+ drflac_uint32 left = right + side;
+
+ left >>= 16;
+ right >>= 16;
+
+ pOutputSamples[i*2+0] = (drflac_int16)left;
+ pOutputSamples[i*2+1] = (drflac_int16)right;
+ }
+}
+#endif
+
+#if defined(DRFLAC_SUPPORT_NEON)
+static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_right_side__neon(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples)
+{
+ drflac_uint64 i;
+ drflac_uint64 frameCount4 = frameCount >> 2;
+ const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0;
+ const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1;
+ drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+ int32x4_t shift0_4;
+ int32x4_t shift1_4;
+
+ DRFLAC_ASSERT(pFlac->bitsPerSample <= 24);
+
+ shift0_4 = vdupq_n_s32(shift0);
+ shift1_4 = vdupq_n_s32(shift1);
+
+ for (i = 0; i < frameCount4; ++i) {
+ uint32x4_t side;
+ uint32x4_t right;
+ uint32x4_t left;
+
+ side = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), shift0_4);
+ right = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), shift1_4);
+ left = vaddq_u32(right, side);
+
+ left = vshrq_n_u32(left, 16);
+ right = vshrq_n_u32(right, 16);
+
+ drflac__vst2q_u16((drflac_uint16*)pOutputSamples + i*8, vzip_u16(vmovn_u32(left), vmovn_u32(right)));
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ drflac_uint32 side = pInputSamples0U32[i] << shift0;
+ drflac_uint32 right = pInputSamples1U32[i] << shift1;
+ drflac_uint32 left = right + side;
+
+ left >>= 16;
+ right >>= 16;
+
+ pOutputSamples[i*2+0] = (drflac_int16)left;
+ pOutputSamples[i*2+1] = (drflac_int16)right;
+ }
+}
+#endif
+
+static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_right_side(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples)
+{
+#if defined(DRFLAC_SUPPORT_SSE2)
+ if (drflac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) {
+ drflac_read_pcm_frames_s16__decode_right_side__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+ } else
+#elif defined(DRFLAC_SUPPORT_NEON)
+ if (drflac__gIsNEONSupported && pFlac->bitsPerSample <= 24) {
+ drflac_read_pcm_frames_s16__decode_right_side__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+ } else
+#endif
+ {
+ /* Scalar fallback. */
+#if 0
+ drflac_read_pcm_frames_s16__decode_right_side__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#else
+ drflac_read_pcm_frames_s16__decode_right_side__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#endif
+ }
+}
+
+
+#if 0
+static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_mid_side__reference(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples)
+{
+ for (drflac_uint64 i = 0; i < frameCount; ++i) {
+ drflac_uint32 mid = (drflac_uint32)pInputSamples0[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 side = (drflac_uint32)pInputSamples1[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+
+ mid = (mid << 1) | (side & 0x01);
+
+ pOutputSamples[i*2+0] = (drflac_int16)(((drflac_uint32)((drflac_int32)(mid + side) >> 1) << unusedBitsPerSample) >> 16);
+ pOutputSamples[i*2+1] = (drflac_int16)(((drflac_uint32)((drflac_int32)(mid - side) >> 1) << unusedBitsPerSample) >> 16);
+ }
+}
+#endif
+
+static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_mid_side__scalar(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples)
+{
+ drflac_uint64 i;
+ drflac_uint64 frameCount4 = frameCount >> 2;
+ const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0;
+ const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1;
+ drflac_uint32 shift = unusedBitsPerSample;
+
+ if (shift > 0) {
+ shift -= 1;
+ for (i = 0; i < frameCount4; ++i) {
+ drflac_uint32 temp0L;
+ drflac_uint32 temp1L;
+ drflac_uint32 temp2L;
+ drflac_uint32 temp3L;
+ drflac_uint32 temp0R;
+ drflac_uint32 temp1R;
+ drflac_uint32 temp2R;
+ drflac_uint32 temp3R;
+
+ drflac_uint32 mid0 = pInputSamples0U32[i*4+0] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 mid1 = pInputSamples0U32[i*4+1] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 mid2 = pInputSamples0U32[i*4+2] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 mid3 = pInputSamples0U32[i*4+3] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+
+ drflac_uint32 side0 = pInputSamples1U32[i*4+0] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+ drflac_uint32 side1 = pInputSamples1U32[i*4+1] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+ drflac_uint32 side2 = pInputSamples1U32[i*4+2] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+ drflac_uint32 side3 = pInputSamples1U32[i*4+3] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+
+ mid0 = (mid0 << 1) | (side0 & 0x01);
+ mid1 = (mid1 << 1) | (side1 & 0x01);
+ mid2 = (mid2 << 1) | (side2 & 0x01);
+ mid3 = (mid3 << 1) | (side3 & 0x01);
+
+ temp0L = (mid0 + side0) << shift;
+ temp1L = (mid1 + side1) << shift;
+ temp2L = (mid2 + side2) << shift;
+ temp3L = (mid3 + side3) << shift;
+
+ temp0R = (mid0 - side0) << shift;
+ temp1R = (mid1 - side1) << shift;
+ temp2R = (mid2 - side2) << shift;
+ temp3R = (mid3 - side3) << shift;
+
+ temp0L >>= 16;
+ temp1L >>= 16;
+ temp2L >>= 16;
+ temp3L >>= 16;
+
+ temp0R >>= 16;
+ temp1R >>= 16;
+ temp2R >>= 16;
+ temp3R >>= 16;
+
+ pOutputSamples[i*8+0] = (drflac_int16)temp0L;
+ pOutputSamples[i*8+1] = (drflac_int16)temp0R;
+ pOutputSamples[i*8+2] = (drflac_int16)temp1L;
+ pOutputSamples[i*8+3] = (drflac_int16)temp1R;
+ pOutputSamples[i*8+4] = (drflac_int16)temp2L;
+ pOutputSamples[i*8+5] = (drflac_int16)temp2R;
+ pOutputSamples[i*8+6] = (drflac_int16)temp3L;
+ pOutputSamples[i*8+7] = (drflac_int16)temp3R;
+ }
+ } else {
+ for (i = 0; i < frameCount4; ++i) {
+ drflac_uint32 temp0L;
+ drflac_uint32 temp1L;
+ drflac_uint32 temp2L;
+ drflac_uint32 temp3L;
+ drflac_uint32 temp0R;
+ drflac_uint32 temp1R;
+ drflac_uint32 temp2R;
+ drflac_uint32 temp3R;
+
+ drflac_uint32 mid0 = pInputSamples0U32[i*4+0] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 mid1 = pInputSamples0U32[i*4+1] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 mid2 = pInputSamples0U32[i*4+2] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 mid3 = pInputSamples0U32[i*4+3] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+
+ drflac_uint32 side0 = pInputSamples1U32[i*4+0] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+ drflac_uint32 side1 = pInputSamples1U32[i*4+1] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+ drflac_uint32 side2 = pInputSamples1U32[i*4+2] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+ drflac_uint32 side3 = pInputSamples1U32[i*4+3] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+
+ mid0 = (mid0 << 1) | (side0 & 0x01);
+ mid1 = (mid1 << 1) | (side1 & 0x01);
+ mid2 = (mid2 << 1) | (side2 & 0x01);
+ mid3 = (mid3 << 1) | (side3 & 0x01);
+
+ temp0L = ((drflac_int32)(mid0 + side0) >> 1);
+ temp1L = ((drflac_int32)(mid1 + side1) >> 1);
+ temp2L = ((drflac_int32)(mid2 + side2) >> 1);
+ temp3L = ((drflac_int32)(mid3 + side3) >> 1);
+
+ temp0R = ((drflac_int32)(mid0 - side0) >> 1);
+ temp1R = ((drflac_int32)(mid1 - side1) >> 1);
+ temp2R = ((drflac_int32)(mid2 - side2) >> 1);
+ temp3R = ((drflac_int32)(mid3 - side3) >> 1);
+
+ temp0L >>= 16;
+ temp1L >>= 16;
+ temp2L >>= 16;
+ temp3L >>= 16;
+
+ temp0R >>= 16;
+ temp1R >>= 16;
+ temp2R >>= 16;
+ temp3R >>= 16;
+
+ pOutputSamples[i*8+0] = (drflac_int16)temp0L;
+ pOutputSamples[i*8+1] = (drflac_int16)temp0R;
+ pOutputSamples[i*8+2] = (drflac_int16)temp1L;
+ pOutputSamples[i*8+3] = (drflac_int16)temp1R;
+ pOutputSamples[i*8+4] = (drflac_int16)temp2L;
+ pOutputSamples[i*8+5] = (drflac_int16)temp2R;
+ pOutputSamples[i*8+6] = (drflac_int16)temp3L;
+ pOutputSamples[i*8+7] = (drflac_int16)temp3R;
+ }
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ drflac_uint32 mid = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+
+ mid = (mid << 1) | (side & 0x01);
+
+ pOutputSamples[i*2+0] = (drflac_int16)(((drflac_uint32)((drflac_int32)(mid + side) >> 1) << unusedBitsPerSample) >> 16);
+ pOutputSamples[i*2+1] = (drflac_int16)(((drflac_uint32)((drflac_int32)(mid - side) >> 1) << unusedBitsPerSample) >> 16);
+ }
+}
+
+#if defined(DRFLAC_SUPPORT_SSE2)
+static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_mid_side__sse2(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples)
+{
+ drflac_uint64 i;
+ drflac_uint64 frameCount4 = frameCount >> 2;
+ const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0;
+ const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1;
+ drflac_uint32 shift = unusedBitsPerSample;
+
+ DRFLAC_ASSERT(pFlac->bitsPerSample <= 24);
+
+ if (shift == 0) {
+ for (i = 0; i < frameCount4; ++i) {
+ __m128i mid;
+ __m128i side;
+ __m128i left;
+ __m128i right;
+
+ mid = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+ side = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+
+ mid = _mm_or_si128(_mm_slli_epi32(mid, 1), _mm_and_si128(side, _mm_set1_epi32(0x01)));
+
+ left = _mm_srai_epi32(_mm_add_epi32(mid, side), 1);
+ right = _mm_srai_epi32(_mm_sub_epi32(mid, side), 1);
+
+ left = _mm_srai_epi32(left, 16);
+ right = _mm_srai_epi32(right, 16);
+
+ _mm_storeu_si128((__m128i*)(pOutputSamples + i*8), drflac__mm_packs_interleaved_epi32(left, right));
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ drflac_uint32 mid = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+
+ mid = (mid << 1) | (side & 0x01);
+
+ pOutputSamples[i*2+0] = (drflac_int16)(((drflac_int32)(mid + side) >> 1) >> 16);
+ pOutputSamples[i*2+1] = (drflac_int16)(((drflac_int32)(mid - side) >> 1) >> 16);
+ }
+ } else {
+ shift -= 1;
+ for (i = 0; i < frameCount4; ++i) {
+ __m128i mid;
+ __m128i side;
+ __m128i left;
+ __m128i right;
+
+ mid = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+ side = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+
+ mid = _mm_or_si128(_mm_slli_epi32(mid, 1), _mm_and_si128(side, _mm_set1_epi32(0x01)));
+
+ left = _mm_slli_epi32(_mm_add_epi32(mid, side), shift);
+ right = _mm_slli_epi32(_mm_sub_epi32(mid, side), shift);
+
+ left = _mm_srai_epi32(left, 16);
+ right = _mm_srai_epi32(right, 16);
+
+ _mm_storeu_si128((__m128i*)(pOutputSamples + i*8), drflac__mm_packs_interleaved_epi32(left, right));
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ drflac_uint32 mid = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+
+ mid = (mid << 1) | (side & 0x01);
+
+ pOutputSamples[i*2+0] = (drflac_int16)(((mid + side) << shift) >> 16);
+ pOutputSamples[i*2+1] = (drflac_int16)(((mid - side) << shift) >> 16);
+ }
+ }
+}
+#endif
+
+#if defined(DRFLAC_SUPPORT_NEON)
+static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_mid_side__neon(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples)
+{
+ drflac_uint64 i;
+ drflac_uint64 frameCount4 = frameCount >> 2;
+ const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0;
+ const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1;
+ drflac_uint32 shift = unusedBitsPerSample;
+ int32x4_t wbpsShift0_4; /* wbps = Wasted Bits Per Sample */
+ int32x4_t wbpsShift1_4; /* wbps = Wasted Bits Per Sample */
+
+ DRFLAC_ASSERT(pFlac->bitsPerSample <= 24);
+
+ wbpsShift0_4 = vdupq_n_s32(pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+ wbpsShift1_4 = vdupq_n_s32(pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+
+ if (shift == 0) {
+ for (i = 0; i < frameCount4; ++i) {
+ uint32x4_t mid;
+ uint32x4_t side;
+ int32x4_t left;
+ int32x4_t right;
+
+ mid = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), wbpsShift0_4);
+ side = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), wbpsShift1_4);
+
+ mid = vorrq_u32(vshlq_n_u32(mid, 1), vandq_u32(side, vdupq_n_u32(1)));
+
+ left = vshrq_n_s32(vreinterpretq_s32_u32(vaddq_u32(mid, side)), 1);
+ right = vshrq_n_s32(vreinterpretq_s32_u32(vsubq_u32(mid, side)), 1);
+
+ left = vshrq_n_s32(left, 16);
+ right = vshrq_n_s32(right, 16);
+
+ drflac__vst2q_s16(pOutputSamples + i*8, vzip_s16(vmovn_s32(left), vmovn_s32(right)));
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ drflac_uint32 mid = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+
+ mid = (mid << 1) | (side & 0x01);
+
+ pOutputSamples[i*2+0] = (drflac_int16)(((drflac_int32)(mid + side) >> 1) >> 16);
+ pOutputSamples[i*2+1] = (drflac_int16)(((drflac_int32)(mid - side) >> 1) >> 16);
+ }
+ } else {
+ int32x4_t shift4;
+
+ shift -= 1;
+ shift4 = vdupq_n_s32(shift);
+
+ for (i = 0; i < frameCount4; ++i) {
+ uint32x4_t mid;
+ uint32x4_t side;
+ int32x4_t left;
+ int32x4_t right;
+
+ mid = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), wbpsShift0_4);
+ side = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), wbpsShift1_4);
+
+ mid = vorrq_u32(vshlq_n_u32(mid, 1), vandq_u32(side, vdupq_n_u32(1)));
+
+ left = vreinterpretq_s32_u32(vshlq_u32(vaddq_u32(mid, side), shift4));
+ right = vreinterpretq_s32_u32(vshlq_u32(vsubq_u32(mid, side), shift4));
+
+ left = vshrq_n_s32(left, 16);
+ right = vshrq_n_s32(right, 16);
+
+ drflac__vst2q_s16(pOutputSamples + i*8, vzip_s16(vmovn_s32(left), vmovn_s32(right)));
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ drflac_uint32 mid = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+
+ mid = (mid << 1) | (side & 0x01);
+
+ pOutputSamples[i*2+0] = (drflac_int16)(((mid + side) << shift) >> 16);
+ pOutputSamples[i*2+1] = (drflac_int16)(((mid - side) << shift) >> 16);
+ }
+ }
+}
+#endif
+
+static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_mid_side(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples)
+{
+#if defined(DRFLAC_SUPPORT_SSE2)
+ if (drflac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) {
+ drflac_read_pcm_frames_s16__decode_mid_side__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+ } else
+#elif defined(DRFLAC_SUPPORT_NEON)
+ if (drflac__gIsNEONSupported && pFlac->bitsPerSample <= 24) {
+ drflac_read_pcm_frames_s16__decode_mid_side__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+ } else
+#endif
+ {
+ /* Scalar fallback. */
+#if 0
+ drflac_read_pcm_frames_s16__decode_mid_side__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#else
+ drflac_read_pcm_frames_s16__decode_mid_side__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#endif
+ }
+}
+
+
+#if 0
+static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_independent_stereo__reference(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples)
+{
+ for (drflac_uint64 i = 0; i < frameCount; ++i) {
+ pOutputSamples[i*2+0] = (drflac_int16)((drflac_int32)((drflac_uint32)pInputSamples0[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample)) >> 16);
+ pOutputSamples[i*2+1] = (drflac_int16)((drflac_int32)((drflac_uint32)pInputSamples1[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample)) >> 16);
+ }
+}
+#endif
+
+static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_independent_stereo__scalar(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples)
+{
+ drflac_uint64 i;
+ drflac_uint64 frameCount4 = frameCount >> 2;
+ const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0;
+ const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1;
+ drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+
+ for (i = 0; i < frameCount4; ++i) {
+ drflac_uint32 tempL0 = pInputSamples0U32[i*4+0] << shift0;
+ drflac_uint32 tempL1 = pInputSamples0U32[i*4+1] << shift0;
+ drflac_uint32 tempL2 = pInputSamples0U32[i*4+2] << shift0;
+ drflac_uint32 tempL3 = pInputSamples0U32[i*4+3] << shift0;
+
+ drflac_uint32 tempR0 = pInputSamples1U32[i*4+0] << shift1;
+ drflac_uint32 tempR1 = pInputSamples1U32[i*4+1] << shift1;
+ drflac_uint32 tempR2 = pInputSamples1U32[i*4+2] << shift1;
+ drflac_uint32 tempR3 = pInputSamples1U32[i*4+3] << shift1;
+
+ tempL0 >>= 16;
+ tempL1 >>= 16;
+ tempL2 >>= 16;
+ tempL3 >>= 16;
+
+ tempR0 >>= 16;
+ tempR1 >>= 16;
+ tempR2 >>= 16;
+ tempR3 >>= 16;
+
+ pOutputSamples[i*8+0] = (drflac_int16)tempL0;
+ pOutputSamples[i*8+1] = (drflac_int16)tempR0;
+ pOutputSamples[i*8+2] = (drflac_int16)tempL1;
+ pOutputSamples[i*8+3] = (drflac_int16)tempR1;
+ pOutputSamples[i*8+4] = (drflac_int16)tempL2;
+ pOutputSamples[i*8+5] = (drflac_int16)tempR2;
+ pOutputSamples[i*8+6] = (drflac_int16)tempL3;
+ pOutputSamples[i*8+7] = (drflac_int16)tempR3;
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ pOutputSamples[i*2+0] = (drflac_int16)((pInputSamples0U32[i] << shift0) >> 16);
+ pOutputSamples[i*2+1] = (drflac_int16)((pInputSamples1U32[i] << shift1) >> 16);
+ }
+}
+
+#if defined(DRFLAC_SUPPORT_SSE2)
+static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_independent_stereo__sse2(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples)
+{
+ drflac_uint64 i;
+ drflac_uint64 frameCount4 = frameCount >> 2;
+ const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0;
+ const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1;
+ drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+
+ for (i = 0; i < frameCount4; ++i) {
+ __m128i left = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), shift0);
+ __m128i right = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), shift1);
+
+ left = _mm_srai_epi32(left, 16);
+ right = _mm_srai_epi32(right, 16);
+
+ /* At this point we have results. We can now pack and interleave these into a single __m128i object and then store the in the output buffer. */
+ _mm_storeu_si128((__m128i*)(pOutputSamples + i*8), drflac__mm_packs_interleaved_epi32(left, right));
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ pOutputSamples[i*2+0] = (drflac_int16)((pInputSamples0U32[i] << shift0) >> 16);
+ pOutputSamples[i*2+1] = (drflac_int16)((pInputSamples1U32[i] << shift1) >> 16);
+ }
+}
+#endif
+
+#if defined(DRFLAC_SUPPORT_NEON)
+static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_independent_stereo__neon(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples)
+{
+ drflac_uint64 i;
+ drflac_uint64 frameCount4 = frameCount >> 2;
+ const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0;
+ const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1;
+ drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+
+ int32x4_t shift0_4 = vdupq_n_s32(shift0);
+ int32x4_t shift1_4 = vdupq_n_s32(shift1);
+
+ for (i = 0; i < frameCount4; ++i) {
+ int32x4_t left;
+ int32x4_t right;
+
+ left = vreinterpretq_s32_u32(vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), shift0_4));
+ right = vreinterpretq_s32_u32(vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), shift1_4));
+
+ left = vshrq_n_s32(left, 16);
+ right = vshrq_n_s32(right, 16);
+
+ drflac__vst2q_s16(pOutputSamples + i*8, vzip_s16(vmovn_s32(left), vmovn_s32(right)));
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ pOutputSamples[i*2+0] = (drflac_int16)((pInputSamples0U32[i] << shift0) >> 16);
+ pOutputSamples[i*2+1] = (drflac_int16)((pInputSamples1U32[i] << shift1) >> 16);
+ }
+}
+#endif
+
+static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_independent_stereo(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples)
+{
+#if defined(DRFLAC_SUPPORT_SSE2)
+ if (drflac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) {
+ drflac_read_pcm_frames_s16__decode_independent_stereo__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+ } else
+#elif defined(DRFLAC_SUPPORT_NEON)
+ if (drflac__gIsNEONSupported && pFlac->bitsPerSample <= 24) {
+ drflac_read_pcm_frames_s16__decode_independent_stereo__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+ } else
+#endif
+ {
+ /* Scalar fallback. */
+#if 0
+ drflac_read_pcm_frames_s16__decode_independent_stereo__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#else
+ drflac_read_pcm_frames_s16__decode_independent_stereo__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#endif
+ }
+}
+
+DRFLAC_API drflac_uint64 drflac_read_pcm_frames_s16(drflac* pFlac, drflac_uint64 framesToRead, drflac_int16* pBufferOut)
+{
+ drflac_uint64 framesRead;
+ drflac_uint32 unusedBitsPerSample;
+
+ if (pFlac == NULL || framesToRead == 0) {
+ return 0;
+ }
+
+ if (pBufferOut == NULL) {
+ return drflac__seek_forward_by_pcm_frames(pFlac, framesToRead);
+ }
+
+ DRFLAC_ASSERT(pFlac->bitsPerSample <= 32);
+ unusedBitsPerSample = 32 - pFlac->bitsPerSample;
+
+ framesRead = 0;
+ while (framesToRead > 0) {
+ /* If we've run out of samples in this frame, go to the next. */
+ if (pFlac->currentFLACFrame.pcmFramesRemaining == 0) {
+ if (!drflac__read_and_decode_next_flac_frame(pFlac)) {
+ break; /* Couldn't read the next frame, so just break from the loop and return. */
+ }
+ } else {
+ unsigned int channelCount = drflac__get_channel_count_from_channel_assignment(pFlac->currentFLACFrame.header.channelAssignment);
+ drflac_uint64 iFirstPCMFrame = pFlac->currentFLACFrame.header.blockSizeInPCMFrames - pFlac->currentFLACFrame.pcmFramesRemaining;
+ drflac_uint64 frameCountThisIteration = framesToRead;
+
+ if (frameCountThisIteration > pFlac->currentFLACFrame.pcmFramesRemaining) {
+ frameCountThisIteration = pFlac->currentFLACFrame.pcmFramesRemaining;
+ }
+
+ if (channelCount == 2) {
+ const drflac_int32* pDecodedSamples0 = pFlac->currentFLACFrame.subframes[0].pSamplesS32 + iFirstPCMFrame;
+ const drflac_int32* pDecodedSamples1 = pFlac->currentFLACFrame.subframes[1].pSamplesS32 + iFirstPCMFrame;
+
+ switch (pFlac->currentFLACFrame.header.channelAssignment)
+ {
+ case DRFLAC_CHANNEL_ASSIGNMENT_LEFT_SIDE:
+ {
+ drflac_read_pcm_frames_s16__decode_left_side(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut);
+ } break;
+
+ case DRFLAC_CHANNEL_ASSIGNMENT_RIGHT_SIDE:
+ {
+ drflac_read_pcm_frames_s16__decode_right_side(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut);
+ } break;
+
+ case DRFLAC_CHANNEL_ASSIGNMENT_MID_SIDE:
+ {
+ drflac_read_pcm_frames_s16__decode_mid_side(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut);
+ } break;
+
+ case DRFLAC_CHANNEL_ASSIGNMENT_INDEPENDENT:
+ default:
+ {
+ drflac_read_pcm_frames_s16__decode_independent_stereo(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut);
+ } break;
+ }
+ } else {
+ /* Generic interleaving. */
+ drflac_uint64 i;
+ for (i = 0; i < frameCountThisIteration; ++i) {
+ unsigned int j;
+ for (j = 0; j < channelCount; ++j) {
+ drflac_int32 sampleS32 = (drflac_int32)((drflac_uint32)(pFlac->currentFLACFrame.subframes[j].pSamplesS32[iFirstPCMFrame + i]) << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[j].wastedBitsPerSample));
+ pBufferOut[(i*channelCount)+j] = (drflac_int16)(sampleS32 >> 16);
+ }
+ }
+ }
+
+ framesRead += frameCountThisIteration;
+ pBufferOut += frameCountThisIteration * channelCount;
+ framesToRead -= frameCountThisIteration;
+ pFlac->currentPCMFrame += frameCountThisIteration;
+ pFlac->currentFLACFrame.pcmFramesRemaining -= (drflac_uint32)frameCountThisIteration;
+ }
+ }
+
+ return framesRead;
+}
+
+
+#if 0
+static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_left_side__reference(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples)
+{
+ drflac_uint64 i;
+ for (i = 0; i < frameCount; ++i) {
+ drflac_uint32 left = (drflac_uint32)pInputSamples0[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+ drflac_uint32 side = (drflac_uint32)pInputSamples1[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+ drflac_uint32 right = left - side;
+
+ pOutputSamples[i*2+0] = (float)((drflac_int32)left / 2147483648.0);
+ pOutputSamples[i*2+1] = (float)((drflac_int32)right / 2147483648.0);
+ }
+}
+#endif
+
+static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_left_side__scalar(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples)
+{
+ drflac_uint64 i;
+ drflac_uint64 frameCount4 = frameCount >> 2;
+ const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0;
+ const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1;
+ drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+
+ float factor = 1 / 2147483648.0;
+
+ for (i = 0; i < frameCount4; ++i) {
+ drflac_uint32 left0 = pInputSamples0U32[i*4+0] << shift0;
+ drflac_uint32 left1 = pInputSamples0U32[i*4+1] << shift0;
+ drflac_uint32 left2 = pInputSamples0U32[i*4+2] << shift0;
+ drflac_uint32 left3 = pInputSamples0U32[i*4+3] << shift0;
+
+ drflac_uint32 side0 = pInputSamples1U32[i*4+0] << shift1;
+ drflac_uint32 side1 = pInputSamples1U32[i*4+1] << shift1;
+ drflac_uint32 side2 = pInputSamples1U32[i*4+2] << shift1;
+ drflac_uint32 side3 = pInputSamples1U32[i*4+3] << shift1;
+
+ drflac_uint32 right0 = left0 - side0;
+ drflac_uint32 right1 = left1 - side1;
+ drflac_uint32 right2 = left2 - side2;
+ drflac_uint32 right3 = left3 - side3;
+
+ pOutputSamples[i*8+0] = (drflac_int32)left0 * factor;
+ pOutputSamples[i*8+1] = (drflac_int32)right0 * factor;
+ pOutputSamples[i*8+2] = (drflac_int32)left1 * factor;
+ pOutputSamples[i*8+3] = (drflac_int32)right1 * factor;
+ pOutputSamples[i*8+4] = (drflac_int32)left2 * factor;
+ pOutputSamples[i*8+5] = (drflac_int32)right2 * factor;
+ pOutputSamples[i*8+6] = (drflac_int32)left3 * factor;
+ pOutputSamples[i*8+7] = (drflac_int32)right3 * factor;
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ drflac_uint32 left = pInputSamples0U32[i] << shift0;
+ drflac_uint32 side = pInputSamples1U32[i] << shift1;
+ drflac_uint32 right = left - side;
+
+ pOutputSamples[i*2+0] = (drflac_int32)left * factor;
+ pOutputSamples[i*2+1] = (drflac_int32)right * factor;
+ }
+}
+
+#if defined(DRFLAC_SUPPORT_SSE2)
+static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_left_side__sse2(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples)
+{
+ drflac_uint64 i;
+ drflac_uint64 frameCount4 = frameCount >> 2;
+ const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0;
+ const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1;
+ drflac_uint32 shift0 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample) - 8;
+ drflac_uint32 shift1 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample) - 8;
+ __m128 factor;
+
+ DRFLAC_ASSERT(pFlac->bitsPerSample <= 24);
+
+ factor = _mm_set1_ps(1.0f / 8388608.0f);
+
+ for (i = 0; i < frameCount4; ++i) {
+ __m128i left = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), shift0);
+ __m128i side = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), shift1);
+ __m128i right = _mm_sub_epi32(left, side);
+ __m128 leftf = _mm_mul_ps(_mm_cvtepi32_ps(left), factor);
+ __m128 rightf = _mm_mul_ps(_mm_cvtepi32_ps(right), factor);
+
+ _mm_storeu_ps(pOutputSamples + i*8 + 0, _mm_unpacklo_ps(leftf, rightf));
+ _mm_storeu_ps(pOutputSamples + i*8 + 4, _mm_unpackhi_ps(leftf, rightf));
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ drflac_uint32 left = pInputSamples0U32[i] << shift0;
+ drflac_uint32 side = pInputSamples1U32[i] << shift1;
+ drflac_uint32 right = left - side;
+
+ pOutputSamples[i*2+0] = (drflac_int32)left / 8388608.0f;
+ pOutputSamples[i*2+1] = (drflac_int32)right / 8388608.0f;
+ }
+}
+#endif
+
+#if defined(DRFLAC_SUPPORT_NEON)
+static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_left_side__neon(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples)
+{
+ drflac_uint64 i;
+ drflac_uint64 frameCount4 = frameCount >> 2;
+ const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0;
+ const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1;
+ drflac_uint32 shift0 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample) - 8;
+ drflac_uint32 shift1 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample) - 8;
+ float32x4_t factor4;
+ int32x4_t shift0_4;
+ int32x4_t shift1_4;
+
+ DRFLAC_ASSERT(pFlac->bitsPerSample <= 24);
+
+ factor4 = vdupq_n_f32(1.0f / 8388608.0f);
+ shift0_4 = vdupq_n_s32(shift0);
+ shift1_4 = vdupq_n_s32(shift1);
+
+ for (i = 0; i < frameCount4; ++i) {
+ uint32x4_t left;
+ uint32x4_t side;
+ uint32x4_t right;
+ float32x4_t leftf;
+ float32x4_t rightf;
+
+ left = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), shift0_4);
+ side = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), shift1_4);
+ right = vsubq_u32(left, side);
+ leftf = vmulq_f32(vcvtq_f32_s32(vreinterpretq_s32_u32(left)), factor4);
+ rightf = vmulq_f32(vcvtq_f32_s32(vreinterpretq_s32_u32(right)), factor4);
+
+ drflac__vst2q_f32(pOutputSamples + i*8, vzipq_f32(leftf, rightf));
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ drflac_uint32 left = pInputSamples0U32[i] << shift0;
+ drflac_uint32 side = pInputSamples1U32[i] << shift1;
+ drflac_uint32 right = left - side;
+
+ pOutputSamples[i*2+0] = (drflac_int32)left / 8388608.0f;
+ pOutputSamples[i*2+1] = (drflac_int32)right / 8388608.0f;
+ }
+}
+#endif
+
+static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_left_side(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples)
+{
+#if defined(DRFLAC_SUPPORT_SSE2)
+ if (drflac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) {
+ drflac_read_pcm_frames_f32__decode_left_side__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+ } else
+#elif defined(DRFLAC_SUPPORT_NEON)
+ if (drflac__gIsNEONSupported && pFlac->bitsPerSample <= 24) {
+ drflac_read_pcm_frames_f32__decode_left_side__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+ } else
+#endif
+ {
+ /* Scalar fallback. */
+#if 0
+ drflac_read_pcm_frames_f32__decode_left_side__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#else
+ drflac_read_pcm_frames_f32__decode_left_side__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#endif
+ }
+}
+
+
+#if 0
+static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_right_side__reference(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples)
+{
+ drflac_uint64 i;
+ for (i = 0; i < frameCount; ++i) {
+ drflac_uint32 side = (drflac_uint32)pInputSamples0[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+ drflac_uint32 right = (drflac_uint32)pInputSamples1[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+ drflac_uint32 left = right + side;
+
+ pOutputSamples[i*2+0] = (float)((drflac_int32)left / 2147483648.0);
+ pOutputSamples[i*2+1] = (float)((drflac_int32)right / 2147483648.0);
+ }
+}
+#endif
+
+static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_right_side__scalar(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples)
+{
+ drflac_uint64 i;
+ drflac_uint64 frameCount4 = frameCount >> 2;
+ const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0;
+ const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1;
+ drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+ float factor = 1 / 2147483648.0;
+
+ for (i = 0; i < frameCount4; ++i) {
+ drflac_uint32 side0 = pInputSamples0U32[i*4+0] << shift0;
+ drflac_uint32 side1 = pInputSamples0U32[i*4+1] << shift0;
+ drflac_uint32 side2 = pInputSamples0U32[i*4+2] << shift0;
+ drflac_uint32 side3 = pInputSamples0U32[i*4+3] << shift0;
+
+ drflac_uint32 right0 = pInputSamples1U32[i*4+0] << shift1;
+ drflac_uint32 right1 = pInputSamples1U32[i*4+1] << shift1;
+ drflac_uint32 right2 = pInputSamples1U32[i*4+2] << shift1;
+ drflac_uint32 right3 = pInputSamples1U32[i*4+3] << shift1;
+
+ drflac_uint32 left0 = right0 + side0;
+ drflac_uint32 left1 = right1 + side1;
+ drflac_uint32 left2 = right2 + side2;
+ drflac_uint32 left3 = right3 + side3;
+
+ pOutputSamples[i*8+0] = (drflac_int32)left0 * factor;
+ pOutputSamples[i*8+1] = (drflac_int32)right0 * factor;
+ pOutputSamples[i*8+2] = (drflac_int32)left1 * factor;
+ pOutputSamples[i*8+3] = (drflac_int32)right1 * factor;
+ pOutputSamples[i*8+4] = (drflac_int32)left2 * factor;
+ pOutputSamples[i*8+5] = (drflac_int32)right2 * factor;
+ pOutputSamples[i*8+6] = (drflac_int32)left3 * factor;
+ pOutputSamples[i*8+7] = (drflac_int32)right3 * factor;
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ drflac_uint32 side = pInputSamples0U32[i] << shift0;
+ drflac_uint32 right = pInputSamples1U32[i] << shift1;
+ drflac_uint32 left = right + side;
+
+ pOutputSamples[i*2+0] = (drflac_int32)left * factor;
+ pOutputSamples[i*2+1] = (drflac_int32)right * factor;
+ }
+}
+
+#if defined(DRFLAC_SUPPORT_SSE2)
+static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_right_side__sse2(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples)
+{
+ drflac_uint64 i;
+ drflac_uint64 frameCount4 = frameCount >> 2;
+ const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0;
+ const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1;
+ drflac_uint32 shift0 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample) - 8;
+ drflac_uint32 shift1 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample) - 8;
+ __m128 factor;
+
+ DRFLAC_ASSERT(pFlac->bitsPerSample <= 24);
+
+ factor = _mm_set1_ps(1.0f / 8388608.0f);
+
+ for (i = 0; i < frameCount4; ++i) {
+ __m128i side = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), shift0);
+ __m128i right = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), shift1);
+ __m128i left = _mm_add_epi32(right, side);
+ __m128 leftf = _mm_mul_ps(_mm_cvtepi32_ps(left), factor);
+ __m128 rightf = _mm_mul_ps(_mm_cvtepi32_ps(right), factor);
+
+ _mm_storeu_ps(pOutputSamples + i*8 + 0, _mm_unpacklo_ps(leftf, rightf));
+ _mm_storeu_ps(pOutputSamples + i*8 + 4, _mm_unpackhi_ps(leftf, rightf));
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ drflac_uint32 side = pInputSamples0U32[i] << shift0;
+ drflac_uint32 right = pInputSamples1U32[i] << shift1;
+ drflac_uint32 left = right + side;
+
+ pOutputSamples[i*2+0] = (drflac_int32)left / 8388608.0f;
+ pOutputSamples[i*2+1] = (drflac_int32)right / 8388608.0f;
+ }
+}
+#endif
+
+#if defined(DRFLAC_SUPPORT_NEON)
+static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_right_side__neon(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples)
+{
+ drflac_uint64 i;
+ drflac_uint64 frameCount4 = frameCount >> 2;
+ const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0;
+ const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1;
+ drflac_uint32 shift0 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample) - 8;
+ drflac_uint32 shift1 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample) - 8;
+ float32x4_t factor4;
+ int32x4_t shift0_4;
+ int32x4_t shift1_4;
+
+ DRFLAC_ASSERT(pFlac->bitsPerSample <= 24);
+
+ factor4 = vdupq_n_f32(1.0f / 8388608.0f);
+ shift0_4 = vdupq_n_s32(shift0);
+ shift1_4 = vdupq_n_s32(shift1);
+
+ for (i = 0; i < frameCount4; ++i) {
+ uint32x4_t side;
+ uint32x4_t right;
+ uint32x4_t left;
+ float32x4_t leftf;
+ float32x4_t rightf;
+
+ side = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), shift0_4);
+ right = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), shift1_4);
+ left = vaddq_u32(right, side);
+ leftf = vmulq_f32(vcvtq_f32_s32(vreinterpretq_s32_u32(left)), factor4);
+ rightf = vmulq_f32(vcvtq_f32_s32(vreinterpretq_s32_u32(right)), factor4);
+
+ drflac__vst2q_f32(pOutputSamples + i*8, vzipq_f32(leftf, rightf));
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ drflac_uint32 side = pInputSamples0U32[i] << shift0;
+ drflac_uint32 right = pInputSamples1U32[i] << shift1;
+ drflac_uint32 left = right + side;
+
+ pOutputSamples[i*2+0] = (drflac_int32)left / 8388608.0f;
+ pOutputSamples[i*2+1] = (drflac_int32)right / 8388608.0f;
+ }
+}
+#endif
+
+static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_right_side(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples)
+{
+#if defined(DRFLAC_SUPPORT_SSE2)
+ if (drflac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) {
+ drflac_read_pcm_frames_f32__decode_right_side__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+ } else
+#elif defined(DRFLAC_SUPPORT_NEON)
+ if (drflac__gIsNEONSupported && pFlac->bitsPerSample <= 24) {
+ drflac_read_pcm_frames_f32__decode_right_side__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+ } else
+#endif
+ {
+ /* Scalar fallback. */
+#if 0
+ drflac_read_pcm_frames_f32__decode_right_side__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#else
+ drflac_read_pcm_frames_f32__decode_right_side__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#endif
+ }
+}
+
+
+#if 0
+static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_mid_side__reference(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples)
+{
+ for (drflac_uint64 i = 0; i < frameCount; ++i) {
+ drflac_uint32 mid = (drflac_uint32)pInputSamples0[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 side = (drflac_uint32)pInputSamples1[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+
+ mid = (mid << 1) | (side & 0x01);
+
+ pOutputSamples[i*2+0] = (float)((((drflac_int32)(mid + side) >> 1) << (unusedBitsPerSample)) / 2147483648.0);
+ pOutputSamples[i*2+1] = (float)((((drflac_int32)(mid - side) >> 1) << (unusedBitsPerSample)) / 2147483648.0);
+ }
+}
+#endif
+
+static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_mid_side__scalar(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples)
+{
+ drflac_uint64 i;
+ drflac_uint64 frameCount4 = frameCount >> 2;
+ const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0;
+ const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1;
+ drflac_uint32 shift = unusedBitsPerSample;
+ float factor = 1 / 2147483648.0;
+
+ if (shift > 0) {
+ shift -= 1;
+ for (i = 0; i < frameCount4; ++i) {
+ drflac_uint32 temp0L;
+ drflac_uint32 temp1L;
+ drflac_uint32 temp2L;
+ drflac_uint32 temp3L;
+ drflac_uint32 temp0R;
+ drflac_uint32 temp1R;
+ drflac_uint32 temp2R;
+ drflac_uint32 temp3R;
+
+ drflac_uint32 mid0 = pInputSamples0U32[i*4+0] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 mid1 = pInputSamples0U32[i*4+1] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 mid2 = pInputSamples0U32[i*4+2] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 mid3 = pInputSamples0U32[i*4+3] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+
+ drflac_uint32 side0 = pInputSamples1U32[i*4+0] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+ drflac_uint32 side1 = pInputSamples1U32[i*4+1] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+ drflac_uint32 side2 = pInputSamples1U32[i*4+2] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+ drflac_uint32 side3 = pInputSamples1U32[i*4+3] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+
+ mid0 = (mid0 << 1) | (side0 & 0x01);
+ mid1 = (mid1 << 1) | (side1 & 0x01);
+ mid2 = (mid2 << 1) | (side2 & 0x01);
+ mid3 = (mid3 << 1) | (side3 & 0x01);
+
+ temp0L = (mid0 + side0) << shift;
+ temp1L = (mid1 + side1) << shift;
+ temp2L = (mid2 + side2) << shift;
+ temp3L = (mid3 + side3) << shift;
+
+ temp0R = (mid0 - side0) << shift;
+ temp1R = (mid1 - side1) << shift;
+ temp2R = (mid2 - side2) << shift;
+ temp3R = (mid3 - side3) << shift;
+
+ pOutputSamples[i*8+0] = (drflac_int32)temp0L * factor;
+ pOutputSamples[i*8+1] = (drflac_int32)temp0R * factor;
+ pOutputSamples[i*8+2] = (drflac_int32)temp1L * factor;
+ pOutputSamples[i*8+3] = (drflac_int32)temp1R * factor;
+ pOutputSamples[i*8+4] = (drflac_int32)temp2L * factor;
+ pOutputSamples[i*8+5] = (drflac_int32)temp2R * factor;
+ pOutputSamples[i*8+6] = (drflac_int32)temp3L * factor;
+ pOutputSamples[i*8+7] = (drflac_int32)temp3R * factor;
+ }
+ } else {
+ for (i = 0; i < frameCount4; ++i) {
+ drflac_uint32 temp0L;
+ drflac_uint32 temp1L;
+ drflac_uint32 temp2L;
+ drflac_uint32 temp3L;
+ drflac_uint32 temp0R;
+ drflac_uint32 temp1R;
+ drflac_uint32 temp2R;
+ drflac_uint32 temp3R;
+
+ drflac_uint32 mid0 = pInputSamples0U32[i*4+0] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 mid1 = pInputSamples0U32[i*4+1] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 mid2 = pInputSamples0U32[i*4+2] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 mid3 = pInputSamples0U32[i*4+3] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+
+ drflac_uint32 side0 = pInputSamples1U32[i*4+0] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+ drflac_uint32 side1 = pInputSamples1U32[i*4+1] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+ drflac_uint32 side2 = pInputSamples1U32[i*4+2] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+ drflac_uint32 side3 = pInputSamples1U32[i*4+3] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+
+ mid0 = (mid0 << 1) | (side0 & 0x01);
+ mid1 = (mid1 << 1) | (side1 & 0x01);
+ mid2 = (mid2 << 1) | (side2 & 0x01);
+ mid3 = (mid3 << 1) | (side3 & 0x01);
+
+ temp0L = (drflac_uint32)((drflac_int32)(mid0 + side0) >> 1);
+ temp1L = (drflac_uint32)((drflac_int32)(mid1 + side1) >> 1);
+ temp2L = (drflac_uint32)((drflac_int32)(mid2 + side2) >> 1);
+ temp3L = (drflac_uint32)((drflac_int32)(mid3 + side3) >> 1);
+
+ temp0R = (drflac_uint32)((drflac_int32)(mid0 - side0) >> 1);
+ temp1R = (drflac_uint32)((drflac_int32)(mid1 - side1) >> 1);
+ temp2R = (drflac_uint32)((drflac_int32)(mid2 - side2) >> 1);
+ temp3R = (drflac_uint32)((drflac_int32)(mid3 - side3) >> 1);
+
+ pOutputSamples[i*8+0] = (drflac_int32)temp0L * factor;
+ pOutputSamples[i*8+1] = (drflac_int32)temp0R * factor;
+ pOutputSamples[i*8+2] = (drflac_int32)temp1L * factor;
+ pOutputSamples[i*8+3] = (drflac_int32)temp1R * factor;
+ pOutputSamples[i*8+4] = (drflac_int32)temp2L * factor;
+ pOutputSamples[i*8+5] = (drflac_int32)temp2R * factor;
+ pOutputSamples[i*8+6] = (drflac_int32)temp3L * factor;
+ pOutputSamples[i*8+7] = (drflac_int32)temp3R * factor;
+ }
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ drflac_uint32 mid = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+
+ mid = (mid << 1) | (side & 0x01);
+
+ pOutputSamples[i*2+0] = (drflac_int32)((drflac_uint32)((drflac_int32)(mid + side) >> 1) << unusedBitsPerSample) * factor;
+ pOutputSamples[i*2+1] = (drflac_int32)((drflac_uint32)((drflac_int32)(mid - side) >> 1) << unusedBitsPerSample) * factor;
+ }
+}
+
+#if defined(DRFLAC_SUPPORT_SSE2)
+static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_mid_side__sse2(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples)
+{
+ drflac_uint64 i;
+ drflac_uint64 frameCount4 = frameCount >> 2;
+ const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0;
+ const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1;
+ drflac_uint32 shift = unusedBitsPerSample - 8;
+ float factor;
+ __m128 factor128;
+
+ DRFLAC_ASSERT(pFlac->bitsPerSample <= 24);
+
+ factor = 1.0f / 8388608.0f;
+ factor128 = _mm_set1_ps(factor);
+
+ if (shift == 0) {
+ for (i = 0; i < frameCount4; ++i) {
+ __m128i mid;
+ __m128i side;
+ __m128i tempL;
+ __m128i tempR;
+ __m128 leftf;
+ __m128 rightf;
+
+ mid = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+ side = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+
+ mid = _mm_or_si128(_mm_slli_epi32(mid, 1), _mm_and_si128(side, _mm_set1_epi32(0x01)));
+
+ tempL = _mm_srai_epi32(_mm_add_epi32(mid, side), 1);
+ tempR = _mm_srai_epi32(_mm_sub_epi32(mid, side), 1);
+
+ leftf = _mm_mul_ps(_mm_cvtepi32_ps(tempL), factor128);
+ rightf = _mm_mul_ps(_mm_cvtepi32_ps(tempR), factor128);
+
+ _mm_storeu_ps(pOutputSamples + i*8 + 0, _mm_unpacklo_ps(leftf, rightf));
+ _mm_storeu_ps(pOutputSamples + i*8 + 4, _mm_unpackhi_ps(leftf, rightf));
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ drflac_uint32 mid = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+
+ mid = (mid << 1) | (side & 0x01);
+
+ pOutputSamples[i*2+0] = ((drflac_int32)(mid + side) >> 1) * factor;
+ pOutputSamples[i*2+1] = ((drflac_int32)(mid - side) >> 1) * factor;
+ }
+ } else {
+ shift -= 1;
+ for (i = 0; i < frameCount4; ++i) {
+ __m128i mid;
+ __m128i side;
+ __m128i tempL;
+ __m128i tempR;
+ __m128 leftf;
+ __m128 rightf;
+
+ mid = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+ side = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+
+ mid = _mm_or_si128(_mm_slli_epi32(mid, 1), _mm_and_si128(side, _mm_set1_epi32(0x01)));
+
+ tempL = _mm_slli_epi32(_mm_add_epi32(mid, side), shift);
+ tempR = _mm_slli_epi32(_mm_sub_epi32(mid, side), shift);
+
+ leftf = _mm_mul_ps(_mm_cvtepi32_ps(tempL), factor128);
+ rightf = _mm_mul_ps(_mm_cvtepi32_ps(tempR), factor128);
+
+ _mm_storeu_ps(pOutputSamples + i*8 + 0, _mm_unpacklo_ps(leftf, rightf));
+ _mm_storeu_ps(pOutputSamples + i*8 + 4, _mm_unpackhi_ps(leftf, rightf));
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ drflac_uint32 mid = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+
+ mid = (mid << 1) | (side & 0x01);
+
+ pOutputSamples[i*2+0] = (drflac_int32)((mid + side) << shift) * factor;
+ pOutputSamples[i*2+1] = (drflac_int32)((mid - side) << shift) * factor;
+ }
+ }
+}
+#endif
+
+#if defined(DRFLAC_SUPPORT_NEON)
+static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_mid_side__neon(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples)
+{
+ drflac_uint64 i;
+ drflac_uint64 frameCount4 = frameCount >> 2;
+ const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0;
+ const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1;
+ drflac_uint32 shift = unusedBitsPerSample - 8;
+ float factor;
+ float32x4_t factor4;
+ int32x4_t shift4;
+ int32x4_t wbps0_4; /* Wasted Bits Per Sample */
+ int32x4_t wbps1_4; /* Wasted Bits Per Sample */
+
+ DRFLAC_ASSERT(pFlac->bitsPerSample <= 24);
+
+ factor = 1.0f / 8388608.0f;
+ factor4 = vdupq_n_f32(factor);
+ wbps0_4 = vdupq_n_s32(pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+ wbps1_4 = vdupq_n_s32(pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+
+ if (shift == 0) {
+ for (i = 0; i < frameCount4; ++i) {
+ int32x4_t lefti;
+ int32x4_t righti;
+ float32x4_t leftf;
+ float32x4_t rightf;
+
+ uint32x4_t mid = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), wbps0_4);
+ uint32x4_t side = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), wbps1_4);
+
+ mid = vorrq_u32(vshlq_n_u32(mid, 1), vandq_u32(side, vdupq_n_u32(1)));
+
+ lefti = vshrq_n_s32(vreinterpretq_s32_u32(vaddq_u32(mid, side)), 1);
+ righti = vshrq_n_s32(vreinterpretq_s32_u32(vsubq_u32(mid, side)), 1);
+
+ leftf = vmulq_f32(vcvtq_f32_s32(lefti), factor4);
+ rightf = vmulq_f32(vcvtq_f32_s32(righti), factor4);
+
+ drflac__vst2q_f32(pOutputSamples + i*8, vzipq_f32(leftf, rightf));
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ drflac_uint32 mid = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+
+ mid = (mid << 1) | (side & 0x01);
+
+ pOutputSamples[i*2+0] = ((drflac_int32)(mid + side) >> 1) * factor;
+ pOutputSamples[i*2+1] = ((drflac_int32)(mid - side) >> 1) * factor;
+ }
+ } else {
+ shift -= 1;
+ shift4 = vdupq_n_s32(shift);
+ for (i = 0; i < frameCount4; ++i) {
+ uint32x4_t mid;
+ uint32x4_t side;
+ int32x4_t lefti;
+ int32x4_t righti;
+ float32x4_t leftf;
+ float32x4_t rightf;
+
+ mid = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), wbps0_4);
+ side = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), wbps1_4);
+
+ mid = vorrq_u32(vshlq_n_u32(mid, 1), vandq_u32(side, vdupq_n_u32(1)));
+
+ lefti = vreinterpretq_s32_u32(vshlq_u32(vaddq_u32(mid, side), shift4));
+ righti = vreinterpretq_s32_u32(vshlq_u32(vsubq_u32(mid, side), shift4));
+
+ leftf = vmulq_f32(vcvtq_f32_s32(lefti), factor4);
+ rightf = vmulq_f32(vcvtq_f32_s32(righti), factor4);
+
+ drflac__vst2q_f32(pOutputSamples + i*8, vzipq_f32(leftf, rightf));
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ drflac_uint32 mid = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+
+ mid = (mid << 1) | (side & 0x01);
+
+ pOutputSamples[i*2+0] = (drflac_int32)((mid + side) << shift) * factor;
+ pOutputSamples[i*2+1] = (drflac_int32)((mid - side) << shift) * factor;
+ }
+ }
+}
+#endif
+
+static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_mid_side(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples)
+{
+#if defined(DRFLAC_SUPPORT_SSE2)
+ if (drflac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) {
+ drflac_read_pcm_frames_f32__decode_mid_side__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+ } else
+#elif defined(DRFLAC_SUPPORT_NEON)
+ if (drflac__gIsNEONSupported && pFlac->bitsPerSample <= 24) {
+ drflac_read_pcm_frames_f32__decode_mid_side__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+ } else
+#endif
+ {
+ /* Scalar fallback. */
+#if 0
+ drflac_read_pcm_frames_f32__decode_mid_side__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#else
+ drflac_read_pcm_frames_f32__decode_mid_side__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#endif
+ }
+}
+
+#if 0
+static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_independent_stereo__reference(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples)
+{
+ for (drflac_uint64 i = 0; i < frameCount; ++i) {
+ pOutputSamples[i*2+0] = (float)((drflac_int32)((drflac_uint32)pInputSamples0[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample)) / 2147483648.0);
+ pOutputSamples[i*2+1] = (float)((drflac_int32)((drflac_uint32)pInputSamples1[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample)) / 2147483648.0);
+ }
+}
+#endif
+
+static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_independent_stereo__scalar(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples)
+{
+ drflac_uint64 i;
+ drflac_uint64 frameCount4 = frameCount >> 2;
+ const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0;
+ const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1;
+ drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+ drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+ float factor = 1 / 2147483648.0;
+
+ for (i = 0; i < frameCount4; ++i) {
+ drflac_uint32 tempL0 = pInputSamples0U32[i*4+0] << shift0;
+ drflac_uint32 tempL1 = pInputSamples0U32[i*4+1] << shift0;
+ drflac_uint32 tempL2 = pInputSamples0U32[i*4+2] << shift0;
+ drflac_uint32 tempL3 = pInputSamples0U32[i*4+3] << shift0;
+
+ drflac_uint32 tempR0 = pInputSamples1U32[i*4+0] << shift1;
+ drflac_uint32 tempR1 = pInputSamples1U32[i*4+1] << shift1;
+ drflac_uint32 tempR2 = pInputSamples1U32[i*4+2] << shift1;
+ drflac_uint32 tempR3 = pInputSamples1U32[i*4+3] << shift1;
+
+ pOutputSamples[i*8+0] = (drflac_int32)tempL0 * factor;
+ pOutputSamples[i*8+1] = (drflac_int32)tempR0 * factor;
+ pOutputSamples[i*8+2] = (drflac_int32)tempL1 * factor;
+ pOutputSamples[i*8+3] = (drflac_int32)tempR1 * factor;
+ pOutputSamples[i*8+4] = (drflac_int32)tempL2 * factor;
+ pOutputSamples[i*8+5] = (drflac_int32)tempR2 * factor;
+ pOutputSamples[i*8+6] = (drflac_int32)tempL3 * factor;
+ pOutputSamples[i*8+7] = (drflac_int32)tempR3 * factor;
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ pOutputSamples[i*2+0] = (drflac_int32)(pInputSamples0U32[i] << shift0) * factor;
+ pOutputSamples[i*2+1] = (drflac_int32)(pInputSamples1U32[i] << shift1) * factor;
+ }
+}
+
+#if defined(DRFLAC_SUPPORT_SSE2)
+static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_independent_stereo__sse2(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples)
+{
+ drflac_uint64 i;
+ drflac_uint64 frameCount4 = frameCount >> 2;
+ const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0;
+ const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1;
+ drflac_uint32 shift0 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample) - 8;
+ drflac_uint32 shift1 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample) - 8;
+
+ float factor = 1.0f / 8388608.0f;
+ __m128 factor128 = _mm_set1_ps(factor);
+
+ for (i = 0; i < frameCount4; ++i) {
+ __m128i lefti;
+ __m128i righti;
+ __m128 leftf;
+ __m128 rightf;
+
+ lefti = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), shift0);
+ righti = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), shift1);
+
+ leftf = _mm_mul_ps(_mm_cvtepi32_ps(lefti), factor128);
+ rightf = _mm_mul_ps(_mm_cvtepi32_ps(righti), factor128);
+
+ _mm_storeu_ps(pOutputSamples + i*8 + 0, _mm_unpacklo_ps(leftf, rightf));
+ _mm_storeu_ps(pOutputSamples + i*8 + 4, _mm_unpackhi_ps(leftf, rightf));
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ pOutputSamples[i*2+0] = (drflac_int32)(pInputSamples0U32[i] << shift0) * factor;
+ pOutputSamples[i*2+1] = (drflac_int32)(pInputSamples1U32[i] << shift1) * factor;
+ }
+}
+#endif
+
+#if defined(DRFLAC_SUPPORT_NEON)
+static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_independent_stereo__neon(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples)
+{
+ drflac_uint64 i;
+ drflac_uint64 frameCount4 = frameCount >> 2;
+ const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0;
+ const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1;
+ drflac_uint32 shift0 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample) - 8;
+ drflac_uint32 shift1 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample) - 8;
+
+ float factor = 1.0f / 8388608.0f;
+ float32x4_t factor4 = vdupq_n_f32(factor);
+ int32x4_t shift0_4 = vdupq_n_s32(shift0);
+ int32x4_t shift1_4 = vdupq_n_s32(shift1);
+
+ for (i = 0; i < frameCount4; ++i) {
+ int32x4_t lefti;
+ int32x4_t righti;
+ float32x4_t leftf;
+ float32x4_t rightf;
+
+ lefti = vreinterpretq_s32_u32(vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), shift0_4));
+ righti = vreinterpretq_s32_u32(vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), shift1_4));
+
+ leftf = vmulq_f32(vcvtq_f32_s32(lefti), factor4);
+ rightf = vmulq_f32(vcvtq_f32_s32(righti), factor4);
+
+ drflac__vst2q_f32(pOutputSamples + i*8, vzipq_f32(leftf, rightf));
+ }
+
+ for (i = (frameCount4 << 2); i < frameCount; ++i) {
+ pOutputSamples[i*2+0] = (drflac_int32)(pInputSamples0U32[i] << shift0) * factor;
+ pOutputSamples[i*2+1] = (drflac_int32)(pInputSamples1U32[i] << shift1) * factor;
+ }
+}
+#endif
+
+static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_independent_stereo(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples)
+{
+#if defined(DRFLAC_SUPPORT_SSE2)
+ if (drflac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) {
+ drflac_read_pcm_frames_f32__decode_independent_stereo__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+ } else
+#elif defined(DRFLAC_SUPPORT_NEON)
+ if (drflac__gIsNEONSupported && pFlac->bitsPerSample <= 24) {
+ drflac_read_pcm_frames_f32__decode_independent_stereo__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+ } else
+#endif
+ {
+ /* Scalar fallback. */
+#if 0
+ drflac_read_pcm_frames_f32__decode_independent_stereo__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#else
+ drflac_read_pcm_frames_f32__decode_independent_stereo__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#endif
+ }
+}
+
+DRFLAC_API drflac_uint64 drflac_read_pcm_frames_f32(drflac* pFlac, drflac_uint64 framesToRead, float* pBufferOut)
+{
+ drflac_uint64 framesRead;
+ drflac_uint32 unusedBitsPerSample;
+
+ if (pFlac == NULL || framesToRead == 0) {
+ return 0;
+ }
+
+ if (pBufferOut == NULL) {
+ return drflac__seek_forward_by_pcm_frames(pFlac, framesToRead);
+ }
+
+ DRFLAC_ASSERT(pFlac->bitsPerSample <= 32);
+ unusedBitsPerSample = 32 - pFlac->bitsPerSample;
+
+ framesRead = 0;
+ while (framesToRead > 0) {
+ /* If we've run out of samples in this frame, go to the next. */
+ if (pFlac->currentFLACFrame.pcmFramesRemaining == 0) {
+ if (!drflac__read_and_decode_next_flac_frame(pFlac)) {
+ break; /* Couldn't read the next frame, so just break from the loop and return. */
+ }
+ } else {
+ unsigned int channelCount = drflac__get_channel_count_from_channel_assignment(pFlac->currentFLACFrame.header.channelAssignment);
+ drflac_uint64 iFirstPCMFrame = pFlac->currentFLACFrame.header.blockSizeInPCMFrames - pFlac->currentFLACFrame.pcmFramesRemaining;
+ drflac_uint64 frameCountThisIteration = framesToRead;
+
+ if (frameCountThisIteration > pFlac->currentFLACFrame.pcmFramesRemaining) {
+ frameCountThisIteration = pFlac->currentFLACFrame.pcmFramesRemaining;
+ }
+
+ if (channelCount == 2) {
+ const drflac_int32* pDecodedSamples0 = pFlac->currentFLACFrame.subframes[0].pSamplesS32 + iFirstPCMFrame;
+ const drflac_int32* pDecodedSamples1 = pFlac->currentFLACFrame.subframes[1].pSamplesS32 + iFirstPCMFrame;
+
+ switch (pFlac->currentFLACFrame.header.channelAssignment)
+ {
+ case DRFLAC_CHANNEL_ASSIGNMENT_LEFT_SIDE:
+ {
+ drflac_read_pcm_frames_f32__decode_left_side(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut);
+ } break;
+
+ case DRFLAC_CHANNEL_ASSIGNMENT_RIGHT_SIDE:
+ {
+ drflac_read_pcm_frames_f32__decode_right_side(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut);
+ } break;
+
+ case DRFLAC_CHANNEL_ASSIGNMENT_MID_SIDE:
+ {
+ drflac_read_pcm_frames_f32__decode_mid_side(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut);
+ } break;
+
+ case DRFLAC_CHANNEL_ASSIGNMENT_INDEPENDENT:
+ default:
+ {
+ drflac_read_pcm_frames_f32__decode_independent_stereo(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut);
+ } break;
+ }
+ } else {
+ /* Generic interleaving. */
+ drflac_uint64 i;
+ for (i = 0; i < frameCountThisIteration; ++i) {
+ unsigned int j;
+ for (j = 0; j < channelCount; ++j) {
+ drflac_int32 sampleS32 = (drflac_int32)((drflac_uint32)(pFlac->currentFLACFrame.subframes[j].pSamplesS32[iFirstPCMFrame + i]) << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[j].wastedBitsPerSample));
+ pBufferOut[(i*channelCount)+j] = (float)(sampleS32 / 2147483648.0);
+ }
+ }
+ }
+
+ framesRead += frameCountThisIteration;
+ pBufferOut += frameCountThisIteration * channelCount;
+ framesToRead -= frameCountThisIteration;
+ pFlac->currentPCMFrame += frameCountThisIteration;
+ pFlac->currentFLACFrame.pcmFramesRemaining -= (unsigned int)frameCountThisIteration;
+ }
+ }
+
+ return framesRead;
+}
+
+
+DRFLAC_API drflac_bool32 drflac_seek_to_pcm_frame(drflac* pFlac, drflac_uint64 pcmFrameIndex)
+{
+ if (pFlac == NULL) {
+ return DRFLAC_FALSE;
+ }
+
+ /* Don't do anything if we're already on the seek point. */
+ if (pFlac->currentPCMFrame == pcmFrameIndex) {
+ return DRFLAC_TRUE;
+ }
+
+ /*
+ If we don't know where the first frame begins then we can't seek. This will happen when the STREAMINFO block was not present
+ when the decoder was opened.
+ */
+ if (pFlac->firstFLACFramePosInBytes == 0) {
+ return DRFLAC_FALSE;
+ }
+
+ if (pcmFrameIndex == 0) {
+ pFlac->currentPCMFrame = 0;
+ return drflac__seek_to_first_frame(pFlac);
+ } else {
+ drflac_bool32 wasSuccessful = DRFLAC_FALSE;
+ drflac_uint64 originalPCMFrame = pFlac->currentPCMFrame;
+
+ /* Clamp the sample to the end. */
+ if (pcmFrameIndex > pFlac->totalPCMFrameCount) {
+ pcmFrameIndex = pFlac->totalPCMFrameCount;
+ }
+
+ /* If the target sample and the current sample are in the same frame we just move the position forward. */
+ if (pcmFrameIndex > pFlac->currentPCMFrame) {
+ /* Forward. */
+ drflac_uint32 offset = (drflac_uint32)(pcmFrameIndex - pFlac->currentPCMFrame);
+ if (pFlac->currentFLACFrame.pcmFramesRemaining > offset) {
+ pFlac->currentFLACFrame.pcmFramesRemaining -= offset;
+ pFlac->currentPCMFrame = pcmFrameIndex;
+ return DRFLAC_TRUE;
+ }
+ } else {
+ /* Backward. */
+ drflac_uint32 offsetAbs = (drflac_uint32)(pFlac->currentPCMFrame - pcmFrameIndex);
+ drflac_uint32 currentFLACFramePCMFrameCount = pFlac->currentFLACFrame.header.blockSizeInPCMFrames;
+ drflac_uint32 currentFLACFramePCMFramesConsumed = currentFLACFramePCMFrameCount - pFlac->currentFLACFrame.pcmFramesRemaining;
+ if (currentFLACFramePCMFramesConsumed > offsetAbs) {
+ pFlac->currentFLACFrame.pcmFramesRemaining += offsetAbs;
+ pFlac->currentPCMFrame = pcmFrameIndex;
+ return DRFLAC_TRUE;
+ }
+ }
+
+ /*
+ Different techniques depending on encapsulation. Using the native FLAC seektable with Ogg encapsulation is a bit awkward so
+ we'll instead use Ogg's natural seeking facility.
+ */
+#ifndef DR_FLAC_NO_OGG
+ if (pFlac->container == drflac_container_ogg)
+ {
+ wasSuccessful = drflac_ogg__seek_to_pcm_frame(pFlac, pcmFrameIndex);
+ }
+ else
+#endif
+ {
+ /* First try seeking via the seek table. If this fails, fall back to a brute force seek which is much slower. */
+ if (/*!wasSuccessful && */!pFlac->_noSeekTableSeek) {
+ wasSuccessful = drflac__seek_to_pcm_frame__seek_table(pFlac, pcmFrameIndex);
+ }
+
+#if !defined(DR_FLAC_NO_CRC)
+ /* Fall back to binary search if seek table seeking fails. This requires the length of the stream to be known. */
+ if (!wasSuccessful && !pFlac->_noBinarySearchSeek && pFlac->totalPCMFrameCount > 0) {
+ wasSuccessful = drflac__seek_to_pcm_frame__binary_search(pFlac, pcmFrameIndex);
+ }
+#endif
+
+ /* Fall back to brute force if all else fails. */
+ if (!wasSuccessful && !pFlac->_noBruteForceSeek) {
+ wasSuccessful = drflac__seek_to_pcm_frame__brute_force(pFlac, pcmFrameIndex);
+ }
+ }
+
+ if (wasSuccessful) {
+ pFlac->currentPCMFrame = pcmFrameIndex;
+ } else {
+ /* Seek failed. Try putting the decoder back to it's original state. */
+ if (drflac_seek_to_pcm_frame(pFlac, originalPCMFrame) == DRFLAC_FALSE) {
+ /* Failed to seek back to the original PCM frame. Fall back to 0. */
+ drflac_seek_to_pcm_frame(pFlac, 0);
+ }
+ }
+
+ return wasSuccessful;
+ }
+}
+
+
+
+/* High Level APIs */
+
+/* SIZE_MAX */
+#if defined(SIZE_MAX)
+ #define DRFLAC_SIZE_MAX SIZE_MAX
+#else
+ #if defined(DRFLAC_64BIT)
+ #define DRFLAC_SIZE_MAX ((drflac_uint64)0xFFFFFFFFFFFFFFFF)
+ #else
+ #define DRFLAC_SIZE_MAX 0xFFFFFFFF
+ #endif
+#endif
+/* End SIZE_MAX */
+
+
+/* Using a macro as the definition of the drflac__full_decode_and_close_*() API family. Sue me. */
+#define DRFLAC_DEFINE_FULL_READ_AND_CLOSE(extension, type) \
+static type* drflac__full_read_and_close_ ## extension (drflac* pFlac, unsigned int* channelsOut, unsigned int* sampleRateOut, drflac_uint64* totalPCMFrameCountOut)\
+{ \
+ type* pSampleData = NULL; \
+ drflac_uint64 totalPCMFrameCount; \
+ \
+ DRFLAC_ASSERT(pFlac != NULL); \
+ \
+ totalPCMFrameCount = pFlac->totalPCMFrameCount; \
+ \
+ if (totalPCMFrameCount == 0) { \
+ type buffer[4096]; \
+ drflac_uint64 pcmFramesRead; \
+ size_t sampleDataBufferSize = sizeof(buffer); \
+ \
+ pSampleData = (type*)drflac__malloc_from_callbacks(sampleDataBufferSize, &pFlac->allocationCallbacks); \
+ if (pSampleData == NULL) { \
+ goto on_error; \
+ } \
+ \
+ while ((pcmFramesRead = (drflac_uint64)drflac_read_pcm_frames_##extension(pFlac, sizeof(buffer)/sizeof(buffer[0])/pFlac->channels, buffer)) > 0) { \
+ if (((totalPCMFrameCount + pcmFramesRead) * pFlac->channels * sizeof(type)) > sampleDataBufferSize) { \
+ type* pNewSampleData; \
+ size_t newSampleDataBufferSize; \
+ \
+ newSampleDataBufferSize = sampleDataBufferSize * 2; \
+ pNewSampleData = (type*)drflac__realloc_from_callbacks(pSampleData, newSampleDataBufferSize, sampleDataBufferSize, &pFlac->allocationCallbacks); \
+ if (pNewSampleData == NULL) { \
+ drflac__free_from_callbacks(pSampleData, &pFlac->allocationCallbacks); \
+ goto on_error; \
+ } \
+ \
+ sampleDataBufferSize = newSampleDataBufferSize; \
+ pSampleData = pNewSampleData; \
+ } \
+ \
+ DRFLAC_COPY_MEMORY(pSampleData + (totalPCMFrameCount*pFlac->channels), buffer, (size_t)(pcmFramesRead*pFlac->channels*sizeof(type))); \
+ totalPCMFrameCount += pcmFramesRead; \
+ } \
+ \
+ /* At this point everything should be decoded, but we just want to fill the unused part buffer with silence - need to \
+ protect those ears from random noise! */ \
+ DRFLAC_ZERO_MEMORY(pSampleData + (totalPCMFrameCount*pFlac->channels), (size_t)(sampleDataBufferSize - totalPCMFrameCount*pFlac->channels*sizeof(type))); \
+ } else { \
+ drflac_uint64 dataSize = totalPCMFrameCount*pFlac->channels*sizeof(type); \
+ if (dataSize > (drflac_uint64)DRFLAC_SIZE_MAX) { \
+ goto on_error; /* The decoded data is too big. */ \
+ } \
+ \
+ pSampleData = (type*)drflac__malloc_from_callbacks((size_t)dataSize, &pFlac->allocationCallbacks); /* <-- Safe cast as per the check above. */ \
+ if (pSampleData == NULL) { \
+ goto on_error; \
+ } \
+ \
+ totalPCMFrameCount = drflac_read_pcm_frames_##extension(pFlac, pFlac->totalPCMFrameCount, pSampleData); \
+ } \
+ \
+ if (sampleRateOut) *sampleRateOut = pFlac->sampleRate; \
+ if (channelsOut) *channelsOut = pFlac->channels; \
+ if (totalPCMFrameCountOut) *totalPCMFrameCountOut = totalPCMFrameCount; \
+ \
+ drflac_close(pFlac); \
+ return pSampleData; \
+ \
+on_error: \
+ drflac_close(pFlac); \
+ return NULL; \
+}
+
+DRFLAC_DEFINE_FULL_READ_AND_CLOSE(s32, drflac_int32)
+DRFLAC_DEFINE_FULL_READ_AND_CLOSE(s16, drflac_int16)
+DRFLAC_DEFINE_FULL_READ_AND_CLOSE(f32, float)
+
+DRFLAC_API drflac_int32* drflac_open_and_read_pcm_frames_s32(drflac_read_proc onRead, drflac_seek_proc onSeek, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, drflac_uint64* totalPCMFrameCountOut, const drflac_allocation_callbacks* pAllocationCallbacks)
+{
+ drflac* pFlac;
+
+ if (channelsOut) {
+ *channelsOut = 0;
+ }
+ if (sampleRateOut) {
+ *sampleRateOut = 0;
+ }
+ if (totalPCMFrameCountOut) {
+ *totalPCMFrameCountOut = 0;
+ }
+
+ pFlac = drflac_open(onRead, onSeek, pUserData, pAllocationCallbacks);
+ if (pFlac == NULL) {
+ return NULL;
+ }
+
+ return drflac__full_read_and_close_s32(pFlac, channelsOut, sampleRateOut, totalPCMFrameCountOut);
+}
+
+DRFLAC_API drflac_int16* drflac_open_and_read_pcm_frames_s16(drflac_read_proc onRead, drflac_seek_proc onSeek, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, drflac_uint64* totalPCMFrameCountOut, const drflac_allocation_callbacks* pAllocationCallbacks)
+{
+ drflac* pFlac;
+
+ if (channelsOut) {
+ *channelsOut = 0;
+ }
+ if (sampleRateOut) {
+ *sampleRateOut = 0;
+ }
+ if (totalPCMFrameCountOut) {
+ *totalPCMFrameCountOut = 0;
+ }
+
+ pFlac = drflac_open(onRead, onSeek, pUserData, pAllocationCallbacks);
+ if (pFlac == NULL) {
+ return NULL;
+ }
+
+ return drflac__full_read_and_close_s16(pFlac, channelsOut, sampleRateOut, totalPCMFrameCountOut);
+}
+
+DRFLAC_API float* drflac_open_and_read_pcm_frames_f32(drflac_read_proc onRead, drflac_seek_proc onSeek, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, drflac_uint64* totalPCMFrameCountOut, const drflac_allocation_callbacks* pAllocationCallbacks)
+{
+ drflac* pFlac;
+
+ if (channelsOut) {
+ *channelsOut = 0;
+ }
+ if (sampleRateOut) {
+ *sampleRateOut = 0;
+ }
+ if (totalPCMFrameCountOut) {
+ *totalPCMFrameCountOut = 0;
+ }
+
+ pFlac = drflac_open(onRead, onSeek, pUserData, pAllocationCallbacks);
+ if (pFlac == NULL) {
+ return NULL;
+ }
+
+ return drflac__full_read_and_close_f32(pFlac, channelsOut, sampleRateOut, totalPCMFrameCountOut);
+}
+
+#ifndef DR_FLAC_NO_STDIO
+DRFLAC_API drflac_int32* drflac_open_file_and_read_pcm_frames_s32(const char* filename, unsigned int* channels, unsigned int* sampleRate, drflac_uint64* totalPCMFrameCount, const drflac_allocation_callbacks* pAllocationCallbacks)
+{
+ drflac* pFlac;
+
+ if (sampleRate) {
+ *sampleRate = 0;
+ }
+ if (channels) {
+ *channels = 0;
+ }
+ if (totalPCMFrameCount) {
+ *totalPCMFrameCount = 0;
+ }
+
+ pFlac = drflac_open_file(filename, pAllocationCallbacks);
+ if (pFlac == NULL) {
+ return NULL;
+ }
+
+ return drflac__full_read_and_close_s32(pFlac, channels, sampleRate, totalPCMFrameCount);
+}
+
+DRFLAC_API drflac_int16* drflac_open_file_and_read_pcm_frames_s16(const char* filename, unsigned int* channels, unsigned int* sampleRate, drflac_uint64* totalPCMFrameCount, const drflac_allocation_callbacks* pAllocationCallbacks)
+{
+ drflac* pFlac;
+
+ if (sampleRate) {
+ *sampleRate = 0;
+ }
+ if (channels) {
+ *channels = 0;
+ }
+ if (totalPCMFrameCount) {
+ *totalPCMFrameCount = 0;
+ }
+
+ pFlac = drflac_open_file(filename, pAllocationCallbacks);
+ if (pFlac == NULL) {
+ return NULL;
+ }
+
+ return drflac__full_read_and_close_s16(pFlac, channels, sampleRate, totalPCMFrameCount);
+}
+
+DRFLAC_API float* drflac_open_file_and_read_pcm_frames_f32(const char* filename, unsigned int* channels, unsigned int* sampleRate, drflac_uint64* totalPCMFrameCount, const drflac_allocation_callbacks* pAllocationCallbacks)
+{
+ drflac* pFlac;
+
+ if (sampleRate) {
+ *sampleRate = 0;
+ }
+ if (channels) {
+ *channels = 0;
+ }
+ if (totalPCMFrameCount) {
+ *totalPCMFrameCount = 0;
+ }
+
+ pFlac = drflac_open_file(filename, pAllocationCallbacks);
+ if (pFlac == NULL) {
+ return NULL;
+ }
+
+ return drflac__full_read_and_close_f32(pFlac, channels, sampleRate, totalPCMFrameCount);
+}
+#endif
+
+DRFLAC_API drflac_int32* drflac_open_memory_and_read_pcm_frames_s32(const void* data, size_t dataSize, unsigned int* channels, unsigned int* sampleRate, drflac_uint64* totalPCMFrameCount, const drflac_allocation_callbacks* pAllocationCallbacks)
+{
+ drflac* pFlac;
+
+ if (sampleRate) {
+ *sampleRate = 0;
+ }
+ if (channels) {
+ *channels = 0;
+ }
+ if (totalPCMFrameCount) {
+ *totalPCMFrameCount = 0;
+ }
+
+ pFlac = drflac_open_memory(data, dataSize, pAllocationCallbacks);
+ if (pFlac == NULL) {
+ return NULL;
+ }
+
+ return drflac__full_read_and_close_s32(pFlac, channels, sampleRate, totalPCMFrameCount);
+}
+
+DRFLAC_API drflac_int16* drflac_open_memory_and_read_pcm_frames_s16(const void* data, size_t dataSize, unsigned int* channels, unsigned int* sampleRate, drflac_uint64* totalPCMFrameCount, const drflac_allocation_callbacks* pAllocationCallbacks)
+{
+ drflac* pFlac;
+
+ if (sampleRate) {
+ *sampleRate = 0;
+ }
+ if (channels) {
+ *channels = 0;
+ }
+ if (totalPCMFrameCount) {
+ *totalPCMFrameCount = 0;
+ }
+
+ pFlac = drflac_open_memory(data, dataSize, pAllocationCallbacks);
+ if (pFlac == NULL) {
+ return NULL;
+ }
+
+ return drflac__full_read_and_close_s16(pFlac, channels, sampleRate, totalPCMFrameCount);
+}
+
+DRFLAC_API float* drflac_open_memory_and_read_pcm_frames_f32(const void* data, size_t dataSize, unsigned int* channels, unsigned int* sampleRate, drflac_uint64* totalPCMFrameCount, const drflac_allocation_callbacks* pAllocationCallbacks)
+{
+ drflac* pFlac;
+
+ if (sampleRate) {
+ *sampleRate = 0;
+ }
+ if (channels) {
+ *channels = 0;
+ }
+ if (totalPCMFrameCount) {
+ *totalPCMFrameCount = 0;
+ }
+
+ pFlac = drflac_open_memory(data, dataSize, pAllocationCallbacks);
+ if (pFlac == NULL) {
+ return NULL;
+ }
+
+ return drflac__full_read_and_close_f32(pFlac, channels, sampleRate, totalPCMFrameCount);
+}
+
+
+DRFLAC_API void drflac_free(void* p, const drflac_allocation_callbacks* pAllocationCallbacks)
+{
+ if (pAllocationCallbacks != NULL) {
+ drflac__free_from_callbacks(p, pAllocationCallbacks);
+ } else {
+ drflac__free_default(p, NULL);
+ }
+}
+
+
+
+
+DRFLAC_API void drflac_init_vorbis_comment_iterator(drflac_vorbis_comment_iterator* pIter, drflac_uint32 commentCount, const void* pComments)
+{
+ if (pIter == NULL) {
+ return;
+ }
+
+ pIter->countRemaining = commentCount;
+ pIter->pRunningData = (const char*)pComments;
+}
+
+DRFLAC_API const char* drflac_next_vorbis_comment(drflac_vorbis_comment_iterator* pIter, drflac_uint32* pCommentLengthOut)
+{
+ drflac_int32 length;
+ const char* pComment;
+
+ /* Safety. */
+ if (pCommentLengthOut) {
+ *pCommentLengthOut = 0;
+ }
+
+ if (pIter == NULL || pIter->countRemaining == 0 || pIter->pRunningData == NULL) {
+ return NULL;
+ }
+
+ length = drflac__le2host_32_ptr_unaligned(pIter->pRunningData);
+ pIter->pRunningData += 4;
+
+ pComment = pIter->pRunningData;
+ pIter->pRunningData += length;
+ pIter->countRemaining -= 1;
+
+ if (pCommentLengthOut) {
+ *pCommentLengthOut = length;
+ }
+
+ return pComment;
+}
+
+
+
+
+DRFLAC_API void drflac_init_cuesheet_track_iterator(drflac_cuesheet_track_iterator* pIter, drflac_uint32 trackCount, const void* pTrackData)
+{
+ if (pIter == NULL) {
+ return;
+ }
+
+ pIter->countRemaining = trackCount;
+ pIter->pRunningData = (const char*)pTrackData;
+}
+
+DRFLAC_API drflac_bool32 drflac_next_cuesheet_track(drflac_cuesheet_track_iterator* pIter, drflac_cuesheet_track* pCuesheetTrack)
+{
+ drflac_cuesheet_track cuesheetTrack;
+ const char* pRunningData;
+ drflac_uint64 offsetHi;
+ drflac_uint64 offsetLo;
+
+ if (pIter == NULL || pIter->countRemaining == 0 || pIter->pRunningData == NULL) {
+ return DRFLAC_FALSE;
+ }
+
+ pRunningData = pIter->pRunningData;
+
+ offsetHi = drflac__be2host_32(*(const drflac_uint32*)pRunningData); pRunningData += 4;
+ offsetLo = drflac__be2host_32(*(const drflac_uint32*)pRunningData); pRunningData += 4;
+ cuesheetTrack.offset = offsetLo | (offsetHi << 32);
+ cuesheetTrack.trackNumber = pRunningData[0]; pRunningData += 1;
+ DRFLAC_COPY_MEMORY(cuesheetTrack.ISRC, pRunningData, sizeof(cuesheetTrack.ISRC)); pRunningData += 12;
+ cuesheetTrack.isAudio = (pRunningData[0] & 0x80) != 0;
+ cuesheetTrack.preEmphasis = (pRunningData[0] & 0x40) != 0; pRunningData += 14;
+ cuesheetTrack.indexCount = pRunningData[0]; pRunningData += 1;
+ cuesheetTrack.pIndexPoints = (const drflac_cuesheet_track_index*)pRunningData; pRunningData += cuesheetTrack.indexCount * sizeof(drflac_cuesheet_track_index);
+
+ pIter->pRunningData = pRunningData;
+ pIter->countRemaining -= 1;
+
+ if (pCuesheetTrack) {
+ *pCuesheetTrack = cuesheetTrack;
+ }
+
+ return DRFLAC_TRUE;
+}
+
+#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))
+ #pragma GCC diagnostic pop
+#endif
+#endif /* dr_flac_c */
+#endif /* DR_FLAC_IMPLEMENTATION */
+
+
+/*
+REVISION HISTORY
+================
+v0.12.42 - 2023-11-02
+ - Fix build for ARMv6-M.
+ - Fix a compilation warning with GCC.
+
+v0.12.41 - 2023-06-17
+ - Fix an incorrect date in revision history. No functional change.
+
+v0.12.40 - 2023-05-22
+ - Minor code restructure. No functional change.
+
+v0.12.39 - 2022-09-17
+ - Fix compilation with DJGPP.
+ - Fix compilation error with Visual Studio 2019 and the ARM build.
+ - Fix an error with SSE 4.1 detection.
+ - Add support for disabling wchar_t with DR_WAV_NO_WCHAR.
+ - Improve compatibility with compilers which lack support for explicit struct packing.
+ - Improve compatibility with low-end and embedded hardware by reducing the amount of stack
+ allocation when loading an Ogg encapsulated file.
+
+v0.12.38 - 2022-04-10
+ - Fix compilation error on older versions of GCC.
+
+v0.12.37 - 2022-02-12
+ - Improve ARM detection.
+
+v0.12.36 - 2022-02-07
+ - Fix a compilation error with the ARM build.
+
+v0.12.35 - 2022-02-06
+ - Fix a bug due to underestimating the amount of precision required for the prediction stage.
+ - Fix some bugs found from fuzz testing.
+
+v0.12.34 - 2022-01-07
+ - Fix some misalignment bugs when reading metadata.
+
+v0.12.33 - 2021-12-22
+ - Fix a bug with seeking when the seek table does not start at PCM frame 0.
+
+v0.12.32 - 2021-12-11
+ - Fix a warning with Clang.
+
+v0.12.31 - 2021-08-16
+ - Silence some warnings.
+
+v0.12.30 - 2021-07-31
+ - Fix platform detection for ARM64.
+
+v0.12.29 - 2021-04-02
+ - Fix a bug where the running PCM frame index is set to an invalid value when over-seeking.
+ - Fix a decoding error due to an incorrect validation check.
+
+v0.12.28 - 2021-02-21
+ - Fix a warning due to referencing _MSC_VER when it is undefined.
+
+v0.12.27 - 2021-01-31
+ - Fix a static analysis warning.
+
+v0.12.26 - 2021-01-17
+ - Fix a compilation warning due to _BSD_SOURCE being deprecated.
+
+v0.12.25 - 2020-12-26
+ - Update documentation.
+
+v0.12.24 - 2020-11-29
+ - Fix ARM64/NEON detection when compiling with MSVC.
+
+v0.12.23 - 2020-11-21
+ - Fix compilation with OpenWatcom.
+
+v0.12.22 - 2020-11-01
+ - Fix an error with the previous release.
+
+v0.12.21 - 2020-11-01
+ - Fix a possible deadlock when seeking.
+ - Improve compiler support for older versions of GCC.
+
+v0.12.20 - 2020-09-08
+ - Fix a compilation error on older compilers.
+
+v0.12.19 - 2020-08-30
+ - Fix a bug due to an undefined 32-bit shift.
+
+v0.12.18 - 2020-08-14
+ - Fix a crash when compiling with clang-cl.
+
+v0.12.17 - 2020-08-02
+ - Simplify sized types.
+
+v0.12.16 - 2020-07-25
+ - Fix a compilation warning.
+
+v0.12.15 - 2020-07-06
+ - Check for negative LPC shifts and return an error.
+
+v0.12.14 - 2020-06-23
+ - Add include guard for the implementation section.
+
+v0.12.13 - 2020-05-16
+ - Add compile-time and run-time version querying.
+ - DRFLAC_VERSION_MINOR
+ - DRFLAC_VERSION_MAJOR
+ - DRFLAC_VERSION_REVISION
+ - DRFLAC_VERSION_STRING
+ - drflac_version()
+ - drflac_version_string()
+
+v0.12.12 - 2020-04-30
+ - Fix compilation errors with VC6.
+
+v0.12.11 - 2020-04-19
+ - Fix some pedantic warnings.
+ - Fix some undefined behaviour warnings.
+
+v0.12.10 - 2020-04-10
+ - Fix some bugs when trying to seek with an invalid seek table.
+
+v0.12.9 - 2020-04-05
+ - Fix warnings.
+
+v0.12.8 - 2020-04-04
+ - Add drflac_open_file_w() and drflac_open_file_with_metadata_w().
+ - Fix some static analysis warnings.
+ - Minor documentation updates.
+
+v0.12.7 - 2020-03-14
+ - Fix compilation errors with VC6.
+
+v0.12.6 - 2020-03-07
+ - Fix compilation error with Visual Studio .NET 2003.
+
+v0.12.5 - 2020-01-30
+ - Silence some static analysis warnings.
+
+v0.12.4 - 2020-01-29
+ - Silence some static analysis warnings.
+
+v0.12.3 - 2019-12-02
+ - Fix some warnings when compiling with GCC and the -Og flag.
+ - Fix a crash in out-of-memory situations.
+ - Fix potential integer overflow bug.
+ - Fix some static analysis warnings.
+ - Fix a possible crash when using custom memory allocators without a custom realloc() implementation.
+ - Fix a bug with binary search seeking where the bits per sample is not a multiple of 8.
+
+v0.12.2 - 2019-10-07
+ - Internal code clean up.
+
+v0.12.1 - 2019-09-29
+ - Fix some Clang Static Analyzer warnings.
+ - Fix an unused variable warning.
+
+v0.12.0 - 2019-09-23
+ - API CHANGE: Add support for user defined memory allocation routines. This system allows the program to specify their own memory allocation
+ routines with a user data pointer for client-specific contextual data. This adds an extra parameter to the end of the following APIs:
+ - drflac_open()
+ - drflac_open_relaxed()
+ - drflac_open_with_metadata()
+ - drflac_open_with_metadata_relaxed()
+ - drflac_open_file()
+ - drflac_open_file_with_metadata()
+ - drflac_open_memory()
+ - drflac_open_memory_with_metadata()
+ - drflac_open_and_read_pcm_frames_s32()
+ - drflac_open_and_read_pcm_frames_s16()
+ - drflac_open_and_read_pcm_frames_f32()
+ - drflac_open_file_and_read_pcm_frames_s32()
+ - drflac_open_file_and_read_pcm_frames_s16()
+ - drflac_open_file_and_read_pcm_frames_f32()
+ - drflac_open_memory_and_read_pcm_frames_s32()
+ - drflac_open_memory_and_read_pcm_frames_s16()
+ - drflac_open_memory_and_read_pcm_frames_f32()
+ Set this extra parameter to NULL to use defaults which is the same as the previous behaviour. Setting this NULL will use
+ DRFLAC_MALLOC, DRFLAC_REALLOC and DRFLAC_FREE.
+ - Remove deprecated APIs:
+ - drflac_read_s32()
+ - drflac_read_s16()
+ - drflac_read_f32()
+ - drflac_seek_to_sample()
+ - drflac_open_and_decode_s32()
+ - drflac_open_and_decode_s16()
+ - drflac_open_and_decode_f32()
+ - drflac_open_and_decode_file_s32()
+ - drflac_open_and_decode_file_s16()
+ - drflac_open_and_decode_file_f32()
+ - drflac_open_and_decode_memory_s32()
+ - drflac_open_and_decode_memory_s16()
+ - drflac_open_and_decode_memory_f32()
+ - Remove drflac.totalSampleCount which is now replaced with drflac.totalPCMFrameCount. You can emulate drflac.totalSampleCount
+ by doing pFlac->totalPCMFrameCount*pFlac->channels.
+ - Rename drflac.currentFrame to drflac.currentFLACFrame to remove ambiguity with PCM frames.
+ - Fix errors when seeking to the end of a stream.
+ - Optimizations to seeking.
+ - SSE improvements and optimizations.
+ - ARM NEON optimizations.
+ - Optimizations to drflac_read_pcm_frames_s16().
+ - Optimizations to drflac_read_pcm_frames_s32().
+
+v0.11.10 - 2019-06-26
+ - Fix a compiler error.
+
+v0.11.9 - 2019-06-16
+ - Silence some ThreadSanitizer warnings.
+
+v0.11.8 - 2019-05-21
+ - Fix warnings.
+
+v0.11.7 - 2019-05-06
+ - C89 fixes.
+
+v0.11.6 - 2019-05-05
+ - Add support for C89.
+ - Fix a compiler warning when CRC is disabled.
+ - Change license to choice of public domain or MIT-0.
+
+v0.11.5 - 2019-04-19
+ - Fix a compiler error with GCC.
+
+v0.11.4 - 2019-04-17
+ - Fix some warnings with GCC when compiling with -std=c99.
+
+v0.11.3 - 2019-04-07
+ - Silence warnings with GCC.
+
+v0.11.2 - 2019-03-10
+ - Fix a warning.
+
+v0.11.1 - 2019-02-17
+ - Fix a potential bug with seeking.
+
+v0.11.0 - 2018-12-16
+ - API CHANGE: Deprecated drflac_read_s32(), drflac_read_s16() and drflac_read_f32() and replaced them with
+ drflac_read_pcm_frames_s32(), drflac_read_pcm_frames_s16() and drflac_read_pcm_frames_f32(). The new APIs take
+ and return PCM frame counts instead of sample counts. To upgrade you will need to change the input count by
+ dividing it by the channel count, and then do the same with the return value.
+ - API_CHANGE: Deprecated drflac_seek_to_sample() and replaced with drflac_seek_to_pcm_frame(). Same rules as
+ the changes to drflac_read_*() apply.
+ - API CHANGE: Deprecated drflac_open_and_decode_*() and replaced with drflac_open_*_and_read_*(). Same rules as
+ the changes to drflac_read_*() apply.
+ - Optimizations.
+
+v0.10.0 - 2018-09-11
+ - Remove the DR_FLAC_NO_WIN32_IO option and the Win32 file IO functionality. If you need to use Win32 file IO you
+ need to do it yourself via the callback API.
+ - Fix the clang build.
+ - Fix undefined behavior.
+ - Fix errors with CUESHEET metdata blocks.
+ - Add an API for iterating over each cuesheet track in the CUESHEET metadata block. This works the same way as the
+ Vorbis comment API.
+ - Other miscellaneous bug fixes, mostly relating to invalid FLAC streams.
+ - Minor optimizations.
+
+v0.9.11 - 2018-08-29
+ - Fix a bug with sample reconstruction.
+
+v0.9.10 - 2018-08-07
+ - Improve 64-bit detection.
+
+v0.9.9 - 2018-08-05
+ - Fix C++ build on older versions of GCC.
+
+v0.9.8 - 2018-07-24
+ - Fix compilation errors.
+
+v0.9.7 - 2018-07-05
+ - Fix a warning.
+
+v0.9.6 - 2018-06-29
+ - Fix some typos.
+
+v0.9.5 - 2018-06-23
+ - Fix some warnings.
+
+v0.9.4 - 2018-06-14
+ - Optimizations to seeking.
+ - Clean up.
+
+v0.9.3 - 2018-05-22
+ - Bug fix.
+
+v0.9.2 - 2018-05-12
+ - Fix a compilation error due to a missing break statement.
+
+v0.9.1 - 2018-04-29
+ - Fix compilation error with Clang.
+
+v0.9 - 2018-04-24
+ - Fix Clang build.
+ - Start using major.minor.revision versioning.
+
+v0.8g - 2018-04-19
+ - Fix build on non-x86/x64 architectures.
+
+v0.8f - 2018-02-02
+ - Stop pretending to support changing rate/channels mid stream.
+
+v0.8e - 2018-02-01
+ - Fix a crash when the block size of a frame is larger than the maximum block size defined by the FLAC stream.
+ - Fix a crash the the Rice partition order is invalid.
+
+v0.8d - 2017-09-22
+ - Add support for decoding streams with ID3 tags. ID3 tags are just skipped.
+
+v0.8c - 2017-09-07
+ - Fix warning on non-x86/x64 architectures.
+
+v0.8b - 2017-08-19
+ - Fix build on non-x86/x64 architectures.
+
+v0.8a - 2017-08-13
+ - A small optimization for the Clang build.
+
+v0.8 - 2017-08-12
+ - API CHANGE: Rename dr_* types to drflac_*.
+ - Optimizations. This brings dr_flac back to about the same class of efficiency as the reference implementation.
+ - Add support for custom implementations of malloc(), realloc(), etc.
+ - Add CRC checking to Ogg encapsulated streams.
+ - Fix VC++ 6 build. This is only for the C++ compiler. The C compiler is not currently supported.
+ - Bug fixes.
+
+v0.7 - 2017-07-23
+ - Add support for opening a stream without a header block. To do this, use drflac_open_relaxed() / drflac_open_with_metadata_relaxed().
+
+v0.6 - 2017-07-22
+ - Add support for recovering from invalid frames. With this change, dr_flac will simply skip over invalid frames as if they
+ never existed. Frames are checked against their sync code, the CRC-8 of the frame header and the CRC-16 of the whole frame.
+
+v0.5 - 2017-07-16
+ - Fix typos.
+ - Change drflac_bool* types to unsigned.
+ - Add CRC checking. This makes dr_flac slower, but can be disabled with #define DR_FLAC_NO_CRC.
+
+v0.4f - 2017-03-10
+ - Fix a couple of bugs with the bitstreaming code.
+
+v0.4e - 2017-02-17
+ - Fix some warnings.
+
+v0.4d - 2016-12-26
+ - Add support for 32-bit floating-point PCM decoding.
+ - Use drflac_int* and drflac_uint* sized types to improve compiler support.
+ - Minor improvements to documentation.
+
+v0.4c - 2016-12-26
+ - Add support for signed 16-bit integer PCM decoding.
+
+v0.4b - 2016-10-23
+ - A minor change to drflac_bool8 and drflac_bool32 types.
+
+v0.4a - 2016-10-11
+ - Rename drBool32 to drflac_bool32 for styling consistency.
+
+v0.4 - 2016-09-29
+ - API/ABI CHANGE: Use fixed size 32-bit booleans instead of the built-in bool type.
+ - API CHANGE: Rename drflac_open_and_decode*() to drflac_open_and_decode*_s32().
+ - API CHANGE: Swap the order of "channels" and "sampleRate" parameters in drflac_open_and_decode*(). Rationale for this is to
+ keep it consistent with drflac_audio.
+
+v0.3f - 2016-09-21
+ - Fix a warning with GCC.
+
+v0.3e - 2016-09-18
+ - Fixed a bug where GCC 4.3+ was not getting properly identified.
+ - Fixed a few typos.
+ - Changed date formats to ISO 8601 (YYYY-MM-DD).
+
+v0.3d - 2016-06-11
+ - Minor clean up.
+
+v0.3c - 2016-05-28
+ - Fixed compilation error.
+
+v0.3b - 2016-05-16
+ - Fixed Linux/GCC build.
+ - Updated documentation.
+
+v0.3a - 2016-05-15
+ - Minor fixes to documentation.
+
+v0.3 - 2016-05-11
+ - Optimizations. Now at about parity with the reference implementation on 32-bit builds.
+ - Lots of clean up.
+
+v0.2b - 2016-05-10
+ - Bug fixes.
+
+v0.2a - 2016-05-10
+ - Made drflac_open_and_decode() more robust.
+ - Removed an unused debugging variable
+
+v0.2 - 2016-05-09
+ - Added support for Ogg encapsulation.
+ - API CHANGE. Have the onSeek callback take a third argument which specifies whether or not the seek
+ should be relative to the start or the current position. Also changes the seeking rules such that
+ seeking offsets will never be negative.
+ - Have drflac_open_and_decode() fail gracefully if the stream has an unknown total sample count.
+
+v0.1b - 2016-05-07
+ - Properly close the file handle in drflac_open_file() and family when the decoder fails to initialize.
+ - Removed a stale comment.
+
+v0.1a - 2016-05-05
+ - Minor formatting changes.
+ - Fixed a warning on the GCC build.
+
+v0.1 - 2016-05-03
+ - Initial versioned release.
+*/
+
+/*
+This software is available as a choice of the following licenses. Choose
+whichever you prefer.
+
+===============================================================================
+ALTERNATIVE 1 - Public Domain (www.unlicense.org)
+===============================================================================
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
+commercial or non-commercial, and by any means.
+
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
+this software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <http://unlicense.org/>
+
+===============================================================================
+ALTERNATIVE 2 - MIT No Attribution
+===============================================================================
+Copyright 2023 David Reid
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
diff --git a/error.h b/error.h
index 96413cb..7ca91ac 100644
--- a/error.h
+++ b/error.h
@@ -2,13 +2,9 @@
#define error_h
typedef enum {
- error_none = 0,
- error_file_not_found,
+ error_none,
error_out_of_memory,
- error_platform_error,
- error_multithreading,
- error_font,
- error_ui
+ error_read_error
} Error;
#endif
diff --git a/font.c b/font.c
deleted file mode 100644
index ba6dfb6..0000000
--- a/font.c
+++ /dev/null
@@ -1,238 +0,0 @@
-#include "memory.h"
-#include "plat.h"
-#include "render.h"
-#include "stb_rect_pack.h"
-#include "stb_truetype.h"
-#include <math.h>
-
-typedef struct {
- Bitmap bmp;
- stbtt_bakedchar glyphs[max_glyphset];
-} Glyph_Set;
-
-struct Font {
- const void* data;
- Heap* heap;
- stbtt_fontinfo info;
- Glyph_Set* sets[max_glyphset];
- int size, height;
-};
-
-int font_height(Font* f) {
- return f->height;
-}
-
-static const char* utf8_to_codepoint(
- const char* p,
- unsigned* dst
-) {
- unsigned res, n;
- switch (*p & 0xf0) {
- case 0xf0 : res = *p & 0x07; n = 3; break;
- case 0xe0 : res = *p & 0x0f; n = 2; break;
- case 0xd0 :
- case 0xc0 : res = *p & 0x1f; n = 1; break;
- default : res = *p; n = 0; break;
- }
- while (n--) {
- res = (res << 6) | (*(++p) & 0x3f);
- }
- *dst = res;
- return p + 1;
-}
-
-static Glyph_Set* load_glyph_set(
- Font* font,
- int idx
-) {
- Glyph_Set* gs;
- Bitmap* bmp;
- int r, i;
- int ascent, descent, linegap, scaled_ascent;
- float s;
- gs = heap_alloc(font->heap, sizeof *gs);
- bmp = &gs->bmp;
- bmp->w = 512;
- bmp->h = 512;
-retry:
- bmp->pixels = heap_alloc(
- font->heap,
- bmp->w * bmp->h * 4
- );
- s =
- stbtt_ScaleForMappingEmToPixels(&font->info, 1) /
- stbtt_ScaleForPixelHeight(&font->info, 1);
- r = stbtt_BakeFontBitmap(
- font->data,
- 0,
- font->size * s,
- (unsigned char*)bmp->pixels,
- bmp->w,
- bmp->h,
- idx * 256,
- 256,
- gs->glyphs
- );
- if (r <= 0) {
- bmp->w *= 2;
- bmp->h *= 2;
- heap_free(font->heap, bmp->pixels);
- goto retry;
- }
-
- stbtt_GetFontVMetrics(&font->info, &ascent, &descent, &linegap);
- s = stbtt_ScaleForMappingEmToPixels(&font->info, font->size);
- scaled_ascent = (int)(ascent * s + 0.5f);
- for (i = 0; i < 256; i++) {
- gs->glyphs[i].yoff += scaled_ascent;
- gs->glyphs[i].xadvance = (float)floor(gs->glyphs[i].xadvance);
- }
- for (i = bmp->w * bmp->h - 1; i >= 0; i--) {
- unsigned char n = ((unsigned char*)bmp->pixels)[i];
- bmp->pixels[i].r = 255;
- bmp->pixels[i].g = 255;
- bmp->pixels[i].b = 255;
- bmp->pixels[i].a = n;
- }
- return gs;
-}
-
-static Glyph_Set* get_glyph_set(
- Font* font,
- int codepoint
-) {
- int idx = (codepoint >> 8) % max_glyphset;
- if (!font->sets[idx]) {
- font->sets[idx] = load_glyph_set(font, idx);
- }
- return font->sets[idx];
-}
-
-void init_font(
- Font* font,
- Heap* heap,
- const unsigned char* raw,
- int size
-) {
- int r, i;
- int ascent, descent, linegap;
- float scale;
- font->heap = heap;
- font->data = raw;
- font->size = size;
- stbtt_bakedchar* g;
- for (i = 0; i < max_glyphset; i++)
- font->sets[i] = 0;
- r = stbtt_InitFont(&font->info, font->data, 0);
- if (!r) {
- print("Invalid font.\n");
- pbreak(error_font);
- }
- stbtt_GetFontVMetrics(
- &font->info,
- &ascent,
- &descent,
- &linegap
- );
- scale = stbtt_ScaleForMappingEmToPixels(
- &font->info,
- size
- );
- font->height = (int)(
- (ascent - descent + linegap) *
- scale + 0.5f
- );
- g = get_glyph_set(font, '\n')->glyphs;
- g['\t'].x1 = g['\t'].x0;
- g['\n'].x1 = g['\n'].x0;
-}
-
-Font* new_font(
- Heap* h,
- const unsigned char* raw,
- int size
-) {
- Font* f;
- f = heap_alloc(h, sizeof *f);
- init_font(f, h, raw, size);
- return f;
-}
-
-Rectangle text_rect(
- Font* font,
- const char* text
-) {
- const char* p = text;
- unsigned codepoint;
- int x = 0;
- Glyph_Set* gs;
- stbtt_bakedchar* g;
- Rectangle re = { 0 }, r;
- while (*p) {
- p = utf8_to_codepoint(p, &codepoint);
- gs = get_glyph_set(font, codepoint);
- g = &gs->glyphs[codepoint & 0xff];
- r.x = x + (int)g->xoff;
- r.y = (int)g->yoff;
- r.w = (int)g->x1 - g->x0;
- r.h = (int)g->y1 - g->y0;
- rect_merge(&re, &r);
- x += (int)g->xadvance;
- }
- return re;
-}
-
-#define rf(expr) \
- const char* p = text; \
- unsigned codepoint; \
- Glyph_Set* gs; \
- stbtt_bakedchar* g; \
- Rectangle r; \
- while (*p) { \
- p = utf8_to_codepoint(p, &codepoint); \
- gs = get_glyph_set(font, codepoint); \
- g = &gs->glyphs[codepoint & 0xff]; \
- r.x = (int)g->x0; \
- r.y = (int)g->y0; \
- r.w = (int)g->x1 - g->x0; \
- r.h = (int)g->y1 - g->y0; \
- expr; \
- x += (int)g->xadvance; \
- }
-
-void rfont_text(
- Font* font,
- int x,
- int y,
- const char* text
-) {
- rf(render_bitmap(
- &gs->bmp,
- x + (int)g->xoff,
- y + (int)g->yoff,
- &r
- ));
-}
-
-void rfont_text_col(
- Font* font,
- int x,
- int y,
- const char* text,
- Colour colour
-) {
- rf(render_bitmap_col(
- &gs->bmp,
- x + (int)g->xoff,
- y + (int)g->yoff,
- &r,
- colour
- ));
-}
-
-#undef rf
-
-#define STB_RECT_PACK_IMPLEMENTATION
-#define STB_TRUETYPE_IMPLEMENTATION
-#include "stb_rect_pack.h"
-#include "stb_truetype.h"
diff --git a/library.c b/library.c
index 7459579..4eb4ab0 100644
--- a/library.c
+++ b/library.c
@@ -1,14 +1,9 @@
-#include <string.h>
-
#include "library.h"
#include "plat.h"
+#include <string.h>
+#include <stdio.h>
-void init_library(Library* l) {
- int i;
- l->song_count = 0;
- for (i = 0; i < max_songs; i++)
- l->songs[i].file[0] = 0;
-}
+#include "dr_flac.h"
static unsigned hash(const char* s) {
const unsigned char* p = (const unsigned char*)s;
@@ -19,30 +14,128 @@ static unsigned hash(const char* s) {
}
Song* find_song(Library* l, const char* path) {
- int i = hash(path) % max_songs;
+ int i = hash(path) % l->cap;
int c;
Song* s;
- for (c = 0; c < max_songs; c++) {
+ for (c = 0; c < l->cap; c++) {
s = &l->songs[i];
- if (!s->file[0] || !strcmp(path, s->file))
+ if (!s->path[0] || !strcmp(path, s->path))
return s;
i++;
- i %= max_songs;
+ i %= l->cap;
}
return 0;
}
-void add_song(void* l, const char* path) {
+static void cap_iter(
+ void* uptr,
+ const char* path
+) {
+ Library* lib = uptr;
+ (void)path;
+ lib->cap++;
+}
+
+static void adder_iter(
+ void* uptr,
+ const char* path
+) {
Song* s;
- s = find_song(l, path);
- if (!s) {
- print_err("Too many songs!");
- return;
+ Library* lib = uptr;
+ s = find_song(lib, path);
+ if (get_song_meta(path, s)) {
+ strcpy(s->path, path);
+ lib->indices[lib->cnt++] = s - lib->songs;
+ }
+}
+
+void build_library(
+ Arena* a,
+ Library* lib,
+ const char* path
+) {
+ int i;
+ lib->cnt = lib->cap = 0;
+ iter_dir(path, cap_iter, lib);
+ lib->cap += 16;
+ lib->songs = arena_alloc(
+ a,
+ lib->cap * sizeof *lib->songs
+ );
+ lib->indices = arena_alloc(
+ a,
+ lib->cap * sizeof *lib->indices
+ );
+ for (i = 0; i < lib->cap; i++)
+ lib->songs[i].path[0] = 0;
+ iter_dir(path, adder_iter, lib);
+}
+
+void parse_vorbis_comment(
+ Song* s,
+ const char* com,
+ int len
+) {
+ /* this is not safe xDDDD idrc */
+ if (len > 64) {
+ len = 64;
+ }
+ if (!memcmp(com, "ARTIST=", 7)) {
+ len -= 7;
+ memcpy(s->artist, com + 7, len);
+ s->artist[len] = 0;
+ } else if (!memcmp(com, "TITLE=", 6)) {
+ len -= 6;
+ memcpy(s->name, com + 6, len);
+ s->name[len] = 0;
+ } else if (!memcmp(com, "ALBUM=", 6)) {
+ len -= 6;
+ memcpy(s->album, com + 6, len);
+ s->album[len] = 0;
+ }
+}
+
+void flac_meta(
+ void* uptr,
+ drflac_metadata* m
+) {
+ Song* s = uptr;
+ drflac_vorbis_comment_iterator i;
+ drflac_uint32 len;
+ const char* c;
+ int size;
+ switch (m->type) {
+ case DRFLAC_METADATA_BLOCK_TYPE_VORBIS_COMMENT:
+ drflac_init_vorbis_comment_iterator(
+ &i,
+ m->data.vorbis_comment.commentCount,
+ m->data.vorbis_comment.pComments
+ );
+ while ((c = drflac_next_vorbis_comment(
+ &i,
+ &len
+ ))) {
+ parse_vorbis_comment(s, c, len);
+ }
+ break;
}
- strcpy(s->file, path);
- strcpy(s->name, path);
}
-void build_library(Library* l, const char* path) {
- iter_dir(path, add_song, l);
+int get_song_meta(const char* path, Song* s) {
+ drflac* f;
+ f = drflac_open_file_with_metadata(
+ path,
+ flac_meta,
+ s,
+ 0
+ );
+ if (f) {
+ drflac_close(f);
+ return 1;
+ }
+ s->path[0] = 0;
+ return 0;
}
+
+#define DR_FLAC_IMPLEMENTATION
+#include "dr_flac.h"
diff --git a/library.h b/library.h
index 7c9e000..e94c10a 100644
--- a/library.h
+++ b/library.h
@@ -1,19 +1,27 @@
#ifndef library_h
#define library_h
-#include "config.h"
+#include "memory.h"
typedef struct {
- char name[song_name_max];
- char file[song_filename_max];
+ char path[256];
+ char name[64];
+ char artist[64];
+ char album[64];
} Song;
typedef struct {
- Song songs[max_songs];
- int song_count;
+ Song* songs;
+ int* indices;
+ int cap, cnt;
} Library;
-void init_library(Library* l);
-void build_library(Library* l, const char* path);
+void build_library(
+ Arena* a,
+ Library* lib,
+ const char* path
+);
+
+int get_song_meta(const char* path, Song* s);
#endif
diff --git a/luigi.c b/luigi.c
new file mode 100644
index 0000000..5c371d6
--- /dev/null
+++ b/luigi.c
@@ -0,0 +1,87 @@
+#include <stddef.h>
+
+/*
+todo get this working proper. i don't think it's
+possible in X however.
+*/
+/*
+#include "memory.h"
+#include "config.h"
+
+Heap ui_heap = { 0 };
+
+static void try_init_heap(void) {
+ if (!ui_heap.buffer) {
+ init_heap(
+ &ui_heap,
+ galloc(ui_memory_size),
+ ui_memory_size
+ );
+ }
+}
+
+void* ui_malloc(size_t size) {
+ try_init_heap();
+ return heap_alloc(&ui_heap, size);
+}
+
+void ui_free(void* ptr) {
+ try_init_heap();
+ heap_free(&ui_heap, ptr);
+}
+
+void* ui_realloc(void* ptr, size_t size) {
+ void* old;
+ size_t os, diff;
+ if (!ptr)
+ return ui_malloc(size);
+ if (!size && ptr)
+ ui_free(ptr);
+ os = heap_block_size(ptr);
+ if (size == os) return ptr;
+ diff = size;
+ if (size > os)
+ diff = os;
+ old = ptr;
+ ptr = ui_malloc(size);
+ memcpy(ptr, old, diff);
+ ui_free(old);
+ return ptr;
+}
+
+void* ui_calloc(size_t c, size_t s) {
+ void* p;
+ s *= c;
+ p = ui_malloc(s);
+ memset(p, 0, s);
+ return p;
+}
+
+#ifdef malloc
+#undef malloc
+#endif
+#ifdef free
+#undef free
+#endif
+#ifdef realloc
+#undef realloc
+#endif
+#ifdef calloc
+#undef calloc
+#endif
+
+#define malloc ui_malloc
+#define free ui_free
+#define realloc ui_realloc
+#define calloc ui_calloc
+*/
+
+#define UI_IMPLEMENTATION
+#include "luigi.h"
+
+/*
+#undef malloc
+#undef free
+#undef realloc
+#undef calloc
+*/
diff --git a/luigi.h b/luigi.h
new file mode 100644
index 0000000..ec1711d
--- /dev/null
+++ b/luigi.h
@@ -0,0 +1,5931 @@
+// TODO UITextbox features - mouse input, multi-line, clipboard, undo, IME support, number dragging.
+// TODO New elements - list view, menu bar.
+// TODO Keyboard navigation - menus, dialogs, tables.
+// TODO Easier to use fonts; GDI font support.
+// TODO Formalize the notion of size-stability? See _UIExpandPaneButtonInvoke.
+
+#include <stdint.h>
+#include <stddef.h>
+#include <stdbool.h>
+#include <stdarg.h>
+
+#ifdef UI_LINUX
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xatom.h>
+#include <X11/cursorfont.h>
+
+#include <xmmintrin.h>
+#endif
+
+#define _UI_TO_STRING_1(x) #x
+#define _UI_TO_STRING_2(x) _UI_TO_STRING_1(x)
+
+#ifdef UI_WINDOWS
+#undef _UNICODE
+#undef UNICODE
+#include <windows.h>
+#include <shellapi.h>
+
+#define UI_ASSERT(x) do { if (!(x)) { ui.assertionFailure = true; \
+ MessageBox(0, "Assertion failure on line " _UI_TO_STRING_2(__LINE__), 0, 0); \
+ ExitProcess(1); } } while (0)
+#define UI_CALLOC(x) HeapAlloc(ui.heap, HEAP_ZERO_MEMORY, (x))
+#define UI_FREE(x) HeapFree(ui.heap, 0, (x))
+#define UI_MALLOC(x) HeapAlloc(ui.heap, 0, (x))
+#define UI_REALLOC _UIHeapReAlloc
+#define UI_CLOCK GetTickCount
+#define UI_CLOCKS_PER_SECOND (1000)
+#define UI_CLOCK_T DWORD
+#endif
+
+#if defined(UI_LINUX)
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <time.h>
+#include <math.h>
+
+#define UI_ASSERT assert
+#define UI_CALLOC(x) calloc(1, (x))
+#define UI_FREE free
+#define UI_MALLOC malloc
+#define UI_REALLOC realloc
+#define UI_CLOCK clock
+#define UI_CLOCKS_PER_SECOND CLOCKS_PER_SEC
+#define UI_CLOCK_T clock_t
+#endif
+
+#if defined(UI_ESSENCE)
+#include <essence.h>
+
+#define UI_ASSERT EsAssert
+#define UI_CALLOC(x) EsHeapAllocate((x), true)
+#define UI_FREE EsHeapFree
+#define UI_MALLOC(x) EsHeapAllocate((x), false)
+#define UI_REALLOC(x, y) EsHeapReallocate((x), (y), false)
+#define UI_CLOCK EsTimeStampMs
+#define UI_CLOCKS_PER_SECOND 1000
+#define UI_CLOCK_T uint64_t
+
+// Callback to allow the application to process messages.
+void _UIMessageProcess(EsMessage *message);
+#endif
+
+#ifdef UI_DEBUG
+#include <stdio.h>
+#endif
+
+#ifdef UI_FREETYPE
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include <freetype/ftbitmap.h>
+#endif
+
+#define UI_SIZE_BUTTON_MINIMUM_WIDTH (100)
+#define UI_SIZE_BUTTON_PADDING (16)
+#define UI_SIZE_BUTTON_HEIGHT (27)
+#define UI_SIZE_BUTTON_CHECKED_AREA (4)
+
+#define UI_SIZE_CHECKBOX_BOX (14)
+#define UI_SIZE_CHECKBOX_GAP (8)
+
+#define UI_SIZE_MENU_ITEM_HEIGHT (24)
+#define UI_SIZE_MENU_ITEM_MINIMUM_WIDTH (160)
+#define UI_SIZE_MENU_ITEM_MARGIN (9)
+
+#define UI_SIZE_GAUGE_WIDTH (200)
+#define UI_SIZE_GAUGE_HEIGHT (22)
+
+#define UI_SIZE_SLIDER_WIDTH (200)
+#define UI_SIZE_SLIDER_HEIGHT (25)
+#define UI_SIZE_SLIDER_THUMB (15)
+#define UI_SIZE_SLIDER_TRACK (5)
+
+#define UI_SIZE_TEXTBOX_MARGIN (3)
+#define UI_SIZE_TEXTBOX_WIDTH (200)
+#define UI_SIZE_TEXTBOX_HEIGHT (27)
+
+#define UI_SIZE_TAB_PANE_SPACE_TOP (2)
+#define UI_SIZE_TAB_PANE_SPACE_LEFT (4)
+
+#define UI_SIZE_SPLITTER (8)
+
+#define UI_SIZE_SCROLL_BAR (16)
+#define UI_SIZE_SCROLL_MINIMUM_THUMB (20)
+
+#define UI_SIZE_CODE_MARGIN (ui.activeFont->glyphWidth * 5)
+#define UI_SIZE_CODE_MARGIN_GAP (ui.activeFont->glyphWidth * 1)
+
+#define UI_SIZE_TABLE_HEADER (26)
+#define UI_SIZE_TABLE_COLUMN_GAP (20)
+#define UI_SIZE_TABLE_ROW (20)
+
+#define UI_SIZE_PANE_MEDIUM_BORDER (5)
+#define UI_SIZE_PANE_MEDIUM_GAP (5)
+#define UI_SIZE_PANE_SMALL_BORDER (3)
+#define UI_SIZE_PANE_SMALL_GAP (3)
+
+#define UI_SIZE_MDI_CHILD_BORDER (6)
+#define UI_SIZE_MDI_CHILD_TITLE (30)
+#define UI_SIZE_MDI_CHILD_CORNER (12)
+#define UI_SIZE_MDI_CHILD_MINIMUM_WIDTH (100)
+#define UI_SIZE_MDI_CHILD_MINIMUM_HEIGHT (50)
+#define UI_SIZE_MDI_CASCADE (30)
+
+#define UI_UPDATE_HOVERED (1)
+#define UI_UPDATE_PRESSED (2)
+#define UI_UPDATE_FOCUSED (3)
+
+typedef enum UIMessage {
+ UI_MSG_PAINT, // dp = pointer to UIPainter
+ UI_MSG_LAYOUT,
+ UI_MSG_DESTROY,
+ UI_MSG_UPDATE, // di = UI_UPDATE_... constant
+ UI_MSG_ANIMATE,
+ UI_MSG_SCROLLED,
+ UI_MSG_GET_WIDTH, // di = height (if known); return width
+ UI_MSG_GET_HEIGHT, // di = width (if known); return height
+ UI_MSG_FIND_BY_POINT, // dp = pointer to UIFindByPoint; return 1 if handled
+ UI_MSG_CLIENT_PARENT, // dp = pointer to UIElement *, set it to the parent for client elements
+
+ UI_MSG_INPUT_EVENTS_START, // not sent to disabled elements
+ UI_MSG_LEFT_DOWN,
+ UI_MSG_LEFT_UP,
+ UI_MSG_MIDDLE_DOWN,
+ UI_MSG_MIDDLE_UP,
+ UI_MSG_RIGHT_DOWN,
+ UI_MSG_RIGHT_UP,
+ UI_MSG_KEY_TYPED, // dp = pointer to UIKeyTyped; return 1 if handled
+ UI_MSG_MOUSE_MOVE,
+ UI_MSG_MOUSE_DRAG,
+ UI_MSG_MOUSE_WHEEL, // di = delta; return 1 if handled
+ UI_MSG_CLICKED,
+ UI_MSG_GET_CURSOR, // return cursor code
+ UI_MSG_PRESSED_DESCENDENT, // dp = pointer to child that is/contains pressed element
+ UI_MSG_INPUT_EVENTS_END,
+
+ UI_MSG_VALUE_CHANGED, // sent to notify that the element's value has changed
+ UI_MSG_TABLE_GET_ITEM, // dp = pointer to UITableGetItem; return string length
+ UI_MSG_CODE_GET_MARGIN_COLOR, // di = line index (starts at 1); return color
+ UI_MSG_CODE_DECORATE_LINE, // dp = pointer to UICodeDecorateLine
+ UI_MSG_WINDOW_CLOSE, // return 1 to prevent default (process exit for UIWindow; close for UIMDIChild)
+ UI_MSG_TAB_SELECTED, // sent to the tab that was selected (not the tab pane itself)
+ UI_MSG_WINDOW_DROP_FILES, // di = count, dp = char ** of paths
+ UI_MSG_WINDOW_ACTIVATE,
+
+ UI_MSG_USER,
+} UIMessage;
+
+#ifdef UI_ESSENCE
+#define UIRectangle EsRectangle
+#else
+typedef struct UIRectangle {
+ int l, r, t, b;
+} UIRectangle;
+#endif
+
+typedef struct UITheme {
+ uint32_t panel1, panel2, selected, border;
+ uint32_t text, textDisabled, textSelected;
+ uint32_t buttonNormal, buttonHovered, buttonPressed, buttonDisabled;
+ uint32_t textboxNormal, textboxFocused;
+ uint32_t codeFocused, codeBackground, codeDefault, codeComment, codeString, codeNumber, codeOperator, codePreprocessor;
+} UITheme;
+
+typedef struct UIPainter {
+ UIRectangle clip;
+ uint32_t *bits;
+ int width, height;
+#ifdef UI_DEBUG
+ int fillCount;
+#endif
+} UIPainter;
+
+typedef struct UIFont {
+ int glyphWidth, glyphHeight;
+
+#ifdef UI_FREETYPE
+ bool isFreeType;
+ FT_Face font;
+ FT_Bitmap glyphs[128];
+ bool glyphsRendered[128];
+ int glyphOffsetsX[128], glyphOffsetsY[128];
+#endif
+} UIFont;
+
+typedef struct UIShortcut {
+ intptr_t code;
+ bool ctrl, shift, alt;
+ void (*invoke)(void *cp);
+ void *cp;
+} UIShortcut;
+
+typedef struct UIStringSelection {
+ int carets[2];
+ uint32_t colorText, colorBackground;
+} UIStringSelection;
+
+typedef struct UIKeyTyped {
+ char *text;
+ int textBytes;
+ intptr_t code;
+} UIKeyTyped;
+
+typedef struct UITableGetItem {
+ char *buffer;
+ size_t bufferBytes;
+ int index, column;
+ bool isSelected;
+} UITableGetItem;
+
+typedef struct UICodeDecorateLine {
+ UIRectangle bounds;
+ int index; // Starting at 1!
+ int x, y; // Position where additional text can be drawn.
+ UIPainter *painter;
+} UICodeDecorateLine;
+
+typedef struct UIFindByPoint {
+ int x, y;
+ struct UIElement *result;
+} UIFindByPoint;
+
+#define UI_RECT_1(x) ((UIRectangle) { (x), (x), (x), (x) })
+#define UI_RECT_1I(x) ((UIRectangle) { (x), -(x), (x), -(x) })
+#define UI_RECT_2(x, y) ((UIRectangle) { (x), (x), (y), (y) })
+#define UI_RECT_2I(x, y) ((UIRectangle) { (x), -(x), (y), -(y) })
+#define UI_RECT_2S(x, y) ((UIRectangle) { 0, (x), 0, (y) })
+#define UI_RECT_4(x, y, z, w) ((UIRectangle) { (x), (y), (z), (w) })
+#define UI_RECT_WIDTH(_r) ((_r).r - (_r).l)
+#define UI_RECT_HEIGHT(_r) ((_r).b - (_r).t)
+#define UI_RECT_TOTAL_H(_r) ((_r).r + (_r).l)
+#define UI_RECT_TOTAL_V(_r) ((_r).b + (_r).t)
+#define UI_RECT_SIZE(_r) UI_RECT_WIDTH(_r), UI_RECT_HEIGHT(_r)
+#define UI_RECT_TOP_LEFT(_r) (_r).l, (_r).t
+#define UI_RECT_BOTTOM_LEFT(_r) (_r).l, (_r).b
+#define UI_RECT_BOTTOM_RIGHT(_r) (_r).r, (_r).b
+#define UI_RECT_ALL(_r) (_r).l, (_r).r, (_r).t, (_r).b
+#define UI_RECT_VALID(_r) (UI_RECT_WIDTH(_r) > 0 && UI_RECT_HEIGHT(_r) > 0)
+
+#define UI_COLOR_ALPHA_F(x) ((((x) >> 24) & 0xFF) / 255.0f)
+#define UI_COLOR_RED_F(x) ((((x) >> 16) & 0xFF) / 255.0f)
+#define UI_COLOR_GREEN_F(x) ((((x) >> 8) & 0xFF) / 255.0f)
+#define UI_COLOR_BLUE_F(x) ((((x) >> 0) & 0xFF) / 255.0f)
+#define UI_COLOR_ALPHA(x) ((((x) >> 24) & 0xFF))
+#define UI_COLOR_RED(x) ((((x) >> 16) & 0xFF))
+#define UI_COLOR_GREEN(x) ((((x) >> 8) & 0xFF))
+#define UI_COLOR_BLUE(x) ((((x) >> 0) & 0xFF))
+#define UI_COLOR_FROM_FLOAT(r, g, b) (((uint32_t) ((r) * 255.0f) << 16) | ((uint32_t) ((g) * 255.0f) << 8) | ((uint32_t) ((b) * 255.0f) << 0))
+#define UI_COLOR_FROM_RGBA_F(r, g, b, a) (((uint32_t) ((r) * 255.0f) << 16) | ((uint32_t) ((g) * 255.0f) << 8) \
+ | ((uint32_t) ((b) * 255.0f) << 0) | ((uint32_t) ((a) * 255.0f) << 24))
+
+#define UI_SWAP(s, a, b) do { s t = (a); (a) = (b); (b) = t; } while (0)
+
+#define UI_CURSOR_ARROW (0)
+#define UI_CURSOR_TEXT (1)
+#define UI_CURSOR_SPLIT_V (2)
+#define UI_CURSOR_SPLIT_H (3)
+#define UI_CURSOR_FLIPPED_ARROW (4)
+#define UI_CURSOR_CROSS_HAIR (5)
+#define UI_CURSOR_HAND (6)
+#define UI_CURSOR_RESIZE_UP (7)
+#define UI_CURSOR_RESIZE_LEFT (8)
+#define UI_CURSOR_RESIZE_UP_RIGHT (9)
+#define UI_CURSOR_RESIZE_UP_LEFT (10)
+#define UI_CURSOR_RESIZE_DOWN (11)
+#define UI_CURSOR_RESIZE_RIGHT (12)
+#define UI_CURSOR_RESIZE_DOWN_RIGHT (13)
+#define UI_CURSOR_RESIZE_DOWN_LEFT (14)
+#define UI_CURSOR_COUNT (15)
+
+#define UI_ALIGN_LEFT (1)
+#define UI_ALIGN_RIGHT (2)
+#define UI_ALIGN_CENTER (3)
+
+extern const int UI_KEYCODE_A;
+extern const int UI_KEYCODE_BACKSPACE;
+extern const int UI_KEYCODE_DELETE;
+extern const int UI_KEYCODE_DOWN;
+extern const int UI_KEYCODE_END;
+extern const int UI_KEYCODE_ENTER;
+extern const int UI_KEYCODE_ESCAPE;
+extern const int UI_KEYCODE_F1;
+extern const int UI_KEYCODE_HOME;
+extern const int UI_KEYCODE_LEFT;
+extern const int UI_KEYCODE_RIGHT;
+extern const int UI_KEYCODE_SPACE;
+extern const int UI_KEYCODE_TAB;
+extern const int UI_KEYCODE_UP;
+extern const int UI_KEYCODE_INSERT;
+extern const int UI_KEYCODE_0;
+
+#define UI_KEYCODE_LETTER(x) (UI_KEYCODE_A + (x) - 'A')
+#define UI_KEYCODE_DIGIT(x) (UI_KEYCODE_0 + (x) - '0')
+#define UI_KEYCODE_FKEY(x) (UI_KEYCODE_F1 + (x) - 1)
+
+typedef struct UIElement {
+#define UI_ELEMENT_V_FILL (1 << 16)
+#define UI_ELEMENT_H_FILL (1 << 17)
+#define UI_ELEMENT_WINDOW (1 << 18)
+#define UI_ELEMENT_PARENT_PUSH (1 << 19)
+#define UI_ELEMENT_TAB_STOP (1 << 20)
+#define UI_ELEMENT_NON_CLIENT (1 << 21) // Don't destroy in UIElementDestroyDescendents, like scroll bars.
+#define UI_ELEMENT_DISABLED (1 << 22) // Don't receive input events.
+
+#define UI_ELEMENT_HIDE (1 << 29)
+#define UI_ELEMENT_DESTROY (1 << 30)
+#define UI_ELEMENT_DESTROY_DESCENDENT (1 << 31)
+
+ uint32_t flags; // First 16 bits are element specific.
+ uint32_t id;
+
+ struct UIElement *parent;
+ struct UIElement *next;
+ struct UIElement *children;
+ struct UIWindow *window;
+
+ UIRectangle bounds, clip;
+
+ void *cp; // Context pointer (for user).
+
+ int (*messageClass)(struct UIElement *element, UIMessage message, int di /* data integer */, void *dp /* data pointer */);
+ int (*messageUser)(struct UIElement *element, UIMessage message, int di, void *dp);
+
+ const char *cClassName;
+} UIElement;
+
+#define UI_SHORTCUT(code, ctrl, shift, alt, invoke, cp) ((UIShortcut) { (code), (ctrl), (shift), (alt), (invoke), (cp) })
+
+typedef struct UIWindow {
+#define UI_WINDOW_MENU (1 << 0)
+#define UI_WINDOW_INSPECTOR (1 << 1)
+#define UI_WINDOW_CENTER_IN_OWNER (1 << 2)
+#define UI_WINDOW_MAXIMIZE (1 << 3)
+
+ UIElement e;
+
+ UIElement *dialog;
+
+ UIShortcut *shortcuts;
+ size_t shortcutCount, shortcutAllocated;
+
+ float scale;
+
+ uint32_t *bits;
+ int width, height;
+ struct UIWindow *next;
+
+ UIElement *hovered, *pressed, *focused, *dialogOldFocus;
+ int pressedButton;
+
+ int cursorX, cursorY;
+ int cursorStyle;
+
+ // Set when a textbox is modified.
+ // Useful for tracking whether changes to the loaded document have been saved.
+ bool textboxModifiedFlag;
+
+ bool ctrl, shift, alt;
+
+ UIRectangle updateRegion;
+
+#ifdef UI_DEBUG
+ float lastFullFillCount;
+#endif
+
+#ifdef UI_LINUX
+ Window window;
+ XImage *image;
+ XIC xic;
+ unsigned ctrlCode, shiftCode, altCode;
+ Window dragSource;
+#endif
+
+#ifdef UI_WINDOWS
+ HWND hwnd;
+ bool trackingLeave;
+#endif
+
+#ifdef UI_ESSENCE
+ EsWindow *window;
+ EsElement *canvas;
+ int cursor;
+#endif
+} UIWindow;
+
+typedef struct UIPanel {
+#define UI_PANEL_HORIZONTAL (1 << 0)
+#define UI_PANEL_GRAY (1 << 2)
+#define UI_PANEL_WHITE (1 << 3)
+#define UI_PANEL_EXPAND (1 << 4)
+#define UI_PANEL_MEDIUM_SPACING (1 << 5)
+#define UI_PANEL_SMALL_SPACING (1 << 6)
+#define UI_PANEL_SCROLL (1 << 7)
+#define UI_PANEL_BORDER (1 << 8)
+ UIElement e;
+ struct UIScrollBar *scrollBar;
+ UIRectangle border;
+ int gap;
+} UIPanel;
+
+typedef struct UIButton {
+#define UI_BUTTON_SMALL (1 << 0)
+#define UI_BUTTON_MENU_ITEM (1 << 1)
+#define UI_BUTTON_CAN_FOCUS (1 << 2)
+#define UI_BUTTON_DROP_DOWN (1 << 3)
+#define UI_BUTTON_CHECKED (1 << 15)
+ UIElement e;
+ char *label;
+ ptrdiff_t labelBytes;
+ void (*invoke)(void *cp);
+} UIButton;
+
+typedef struct UICheckbox {
+#define UI_CHECKBOX_ALLOW_INDETERMINATE (1 << 0)
+ UIElement e;
+#define UI_CHECK_UNCHECKED (0)
+#define UI_CHECK_CHECKED (1)
+#define UI_CHECK_INDETERMINATE (2)
+ uint8_t check;
+ char *label;
+ ptrdiff_t labelBytes;
+ void (*invoke)(void *cp);
+} UICheckbox;
+
+typedef struct UILabel {
+ UIElement e;
+ char *label;
+ ptrdiff_t labelBytes;
+} UILabel;
+
+typedef struct UISpacer {
+#define UI_SPACER_LINE (1 << 0)
+ UIElement e;
+ int width, height;
+} UISpacer;
+
+typedef struct UISplitPane {
+#define UI_SPLIT_PANE_VERTICAL (1 << 0)
+ UIElement e;
+ float weight;
+} UISplitPane;
+
+typedef struct UITabPane {
+ UIElement e;
+ char *tabs;
+ int active;
+} UITabPane;
+
+typedef struct UIScrollBar {
+#define UI_SCROLL_BAR_HORIZONTAL (1 << 0)
+ UIElement e;
+ int64_t maximum, page;
+ int64_t dragOffset;
+ double position;
+ uint64_t lastAnimateTime;
+ bool inDrag, horizontal;
+} UIScrollBar;
+
+typedef struct UICodeLine {
+ int offset, bytes;
+} UICodeLine;
+
+typedef struct UICode {
+#define UI_CODE_NO_MARGIN (1 << 0)
+ UIElement e;
+ UIScrollBar *vScroll;
+ UICodeLine *lines;
+ UIFont *font;
+ int lineCount, focused;
+ bool moveScrollToFocusNextLayout;
+ char *content;
+ size_t contentBytes;
+ int tabSize;
+} UICode;
+
+typedef struct UIGauge {
+ UIElement e;
+ float position;
+} UIGauge;
+
+typedef struct UITable {
+ UIElement e;
+ UIScrollBar *vScroll;
+ int itemCount;
+ char *columns;
+ int *columnWidths, columnCount, columnHighlight;
+} UITable;
+
+typedef struct UITextbox {
+ UIElement e;
+ char *string;
+ ptrdiff_t bytes;
+ int carets[2];
+ int scroll;
+ bool rejectNextKey;
+} UITextbox;
+
+#define UI_MENU_PLACE_ABOVE (1 << 0)
+#define UI_MENU_NO_SCROLL (1 << 1)
+#ifdef UI_ESSENCE
+typedef EsMenu UIMenu;
+#else
+typedef struct UIMenu {
+ UIElement e;
+ int pointX, pointY;
+ UIScrollBar *vScroll;
+} UIMenu;
+#endif
+
+typedef struct UISlider {
+ UIElement e;
+ float position;
+ int steps;
+} UISlider;
+
+typedef struct UIColorPicker {
+#define UI_COLOR_PICKER_HAS_OPACITY (1 << 0)
+ UIElement e;
+ float hue, saturation, value, opacity;
+} UIColorPicker;
+
+typedef struct UIMDIClient {
+#define UI_MDI_CLIENT_TRANSPARENT (1 << 0)
+ UIElement e;
+ struct UIMDIChild *active;
+ int cascade;
+} UIMDIClient;
+
+typedef struct UIMDIChild {
+#define UI_MDI_CHILD_CLOSE_BUTTON (1 << 0)
+ UIElement e;
+ UIRectangle bounds;
+ char *title;
+ ptrdiff_t titleBytes;
+ int dragHitTest;
+ UIRectangle dragOffset;
+ struct UIMDIChild *previous;
+} UIMDIChild;
+
+typedef struct UIExpandPane {
+ UIElement e;
+ UIButton *button;
+ UIPanel *panel;
+ bool expanded;
+} UIExpandPane;
+
+typedef struct UIImageDisplay {
+#define UI_IMAGE_DISPLAY_INTERACTIVE (1 << 0)
+#define _UI_IMAGE_DISPLAY_ZOOM_FIT (1 << 1)
+
+ UIElement e;
+ uint32_t *bits;
+ int width, height;
+ float panX, panY, zoom;
+
+ // Internals:
+ int previousWidth, previousHeight;
+ int previousPanPointX, previousPanPointY;
+} UIImageDisplay;
+
+typedef struct UIWrapPanel {
+ UIElement e;
+} UIWrapPanel;
+
+void UIInitialise();
+int UIMessageLoop();
+
+UIElement *UIElementCreate(size_t bytes, UIElement *parent, uint32_t flags,
+ int (*messageClass)(UIElement *, UIMessage, int, void *), const char *cClassName);
+
+UIButton *UIButtonCreate(UIElement *parent, uint32_t flags, const char *label, ptrdiff_t labelBytes);
+UICheckbox *UICheckboxCreate(UIElement *parent, uint32_t flags, const char *label, ptrdiff_t labelBytes);
+UIColorPicker *UIColorPickerCreate(UIElement *parent, uint32_t flags);
+UIExpandPane *UIExpandPaneCreate(UIElement *parent, uint32_t flags, const char *label, ptrdiff_t labelBytes, uint32_t panelFlags);
+UIGauge *UIGaugeCreate(UIElement *parent, uint32_t flags);
+UIMDIClient *UIMDIClientCreate(UIElement *parent, uint32_t flags);
+UIMDIChild *UIMDIChildCreate(UIElement *parent, uint32_t flags, UIRectangle initialBounds, const char *title, ptrdiff_t titleBytes);
+UIPanel *UIPanelCreate(UIElement *parent, uint32_t flags);
+UIScrollBar *UIScrollBarCreate(UIElement *parent, uint32_t flags);
+UISlider *UISliderCreate(UIElement *parent, uint32_t flags);
+UISpacer *UISpacerCreate(UIElement *parent, uint32_t flags, int width, int height);
+UISplitPane *UISplitPaneCreate(UIElement *parent, uint32_t flags, float weight);
+UITabPane *UITabPaneCreate(UIElement *parent, uint32_t flags, const char *tabs /* separate with \t, terminate with \0 */);
+UIWrapPanel *UIWrapPanelCreate(UIElement *parent, uint32_t flags);
+
+UILabel *UILabelCreate(UIElement *parent, uint32_t flags, const char *label, ptrdiff_t labelBytes);
+void UILabelSetContent(UILabel *code, const char *content, ptrdiff_t byteCount);
+
+UIImageDisplay *UIImageDisplayCreate(UIElement *parent, uint32_t flags, uint32_t *bits, size_t width, size_t height, size_t stride);
+void UIImageDisplaySetContent(UIImageDisplay *display, uint32_t *bits, size_t width, size_t height, size_t stride);
+
+UIWindow *UIWindowCreate(UIWindow *owner, uint32_t flags, const char *cTitle, int width, int height);
+void UIWindowRegisterShortcut(UIWindow *window, UIShortcut shortcut);
+void UIWindowPostMessage(UIWindow *window, UIMessage message, void *dp); // Thread-safe.
+void UIWindowPack(UIWindow *window, int width); // Change the size of the window to best match its contents.
+
+typedef void (*UIDialogUserCallback)(UIElement *);
+const char *UIDialogShow(UIWindow *window, uint32_t flags, const char *format, ...);
+
+UIMenu *UIMenuCreate(UIElement *parent, uint32_t flags);
+void UIMenuAddItem(UIMenu *menu, uint32_t flags, const char *label, ptrdiff_t labelBytes, void (*invoke)(void *cp), void *cp);
+void UIMenuShow(UIMenu *menu);
+
+UITextbox *UITextboxCreate(UIElement *parent, uint32_t flags);
+void UITextboxReplace(UITextbox *textbox, const char *text, ptrdiff_t bytes, bool sendChangedMessage);
+void UITextboxClear(UITextbox *textbox, bool sendChangedMessage);
+void UITextboxMoveCaret(UITextbox *textbox, bool backward, bool word);
+
+UITable *UITableCreate(UIElement *parent, uint32_t flags, const char *columns /* separate with \t, terminate with \0 */);
+int UITableHitTest(UITable *table, int x, int y); // Returns item index. Returns -1 if not on an item.
+int UITableHeaderHitTest(UITable *table, int x, int y); // Returns column index or -1.
+bool UITableEnsureVisible(UITable *table, int index); // Returns false if the item was already visible.
+void UITableResizeColumns(UITable *table);
+
+UICode *UICodeCreate(UIElement *parent, uint32_t flags);
+void UICodeFocusLine(UICode *code, int index); // Line numbers are 1-indexed!!
+int UICodeHitTest(UICode *code, int x, int y); // Returns line number; negates if in margin. Returns 0 if not on a line.
+void UICodeInsertContent(UICode *code, const char *content, ptrdiff_t byteCount, bool replace);
+
+void UIDrawBlock(UIPainter *painter, UIRectangle rectangle, uint32_t color);
+void UIDrawInvert(UIPainter *painter, UIRectangle rectangle);
+bool UIDrawLine(UIPainter *painter, int x0, int y0, int x1, int y1, uint32_t color); // Returns false if the line was not visible.
+void UIDrawTriangle(UIPainter *painter, int x0, int y0, int x1, int y1, int x2, int y2, uint32_t color);
+void UIDrawTriangleOutline(UIPainter *painter, int x0, int y0, int x1, int y1, int x2, int y2, uint32_t color);
+void UIDrawGlyph(UIPainter *painter, int x, int y, int c, uint32_t color);
+void UIDrawRectangle(UIPainter *painter, UIRectangle r, uint32_t mainColor, uint32_t borderColor, UIRectangle borderSize);
+void UIDrawBorder(UIPainter *painter, UIRectangle r, uint32_t borderColor, UIRectangle borderSize);
+void UIDrawString(UIPainter *painter, UIRectangle r, const char *string, ptrdiff_t bytes, uint32_t color, int align, UIStringSelection *selection);
+int UIDrawStringHighlighted(UIPainter *painter, UIRectangle r, const char *string, ptrdiff_t bytes, int tabSize);
+
+int UIMeasureStringWidth(const char *string, ptrdiff_t bytes);
+int UIMeasureStringHeight();
+
+uint64_t UIAnimateClock(); // In ms.
+
+bool UIElementAnimate(UIElement *element, bool stop);
+void UIElementDestroy(UIElement *element);
+void UIElementDestroyDescendents(UIElement *element);
+UIElement *UIElementFindByPoint(UIElement *element, int x, int y);
+void UIElementFocus(UIElement *element);
+UIRectangle UIElementScreenBounds(UIElement *element); // Returns bounds of element in same coordinate system as used by UIWindowCreate.
+void UIElementRefresh(UIElement *element);
+void UIElementRepaint(UIElement *element, UIRectangle *region);
+void UIElementMove(UIElement *element, UIRectangle bounds, bool alwaysLayout);
+int UIElementMessage(UIElement *element, UIMessage message, int di, void *dp);
+void UIElementChangeParent(UIElement *element, UIElement *newParent, UIElement *insertBefore); // Set insertBefore to null to insert at the end.
+
+UIElement *UIParentPush(UIElement *element);
+UIElement *UIParentPop();
+
+UIRectangle UIRectangleIntersection(UIRectangle a, UIRectangle b);
+UIRectangle UIRectangleBounding(UIRectangle a, UIRectangle b);
+UIRectangle UIRectangleAdd(UIRectangle a, UIRectangle b);
+UIRectangle UIRectangleTranslate(UIRectangle a, UIRectangle b);
+bool UIRectangleEquals(UIRectangle a, UIRectangle b);
+bool UIRectangleContains(UIRectangle a, int x, int y);
+
+bool UIColorToHSV(uint32_t rgb, float *hue, float *saturation, float *value);
+void UIColorToRGB(float hue, float saturation, float value, uint32_t *rgb);
+
+char *UIStringCopy(const char *in, ptrdiff_t inBytes);
+
+UIFont *UIFontCreate(const char *cPath, uint32_t size);
+UIFont *UIFontActivate(UIFont *font); // Returns the previously active font.
+
+#ifdef UI_DEBUG
+void UIInspectorLog(const char *cFormat, ...);
+#endif
+
+#ifdef UI_IMPLEMENTATION
+
+struct {
+ UIWindow *windows;
+ UIElement *animating;
+ UITheme theme;
+
+ UIElement *parentStack[16];
+ int parentStackCount;
+
+ bool quit;
+ const char *dialogResult;
+ UIElement *dialogOldFocus;
+
+ UIFont *activeFont;
+
+#ifdef UI_DEBUG
+ UIWindow *inspector;
+ UITable *inspectorTable;
+ UIWindow *inspectorTarget;
+ UICode *inspectorLog;
+#endif
+
+#ifdef UI_LINUX
+ Display *display;
+ Visual *visual;
+ XIM xim;
+ Atom windowClosedID, primaryID, uriListID, plainTextID;
+ Atom dndEnterID, dndPositionID, dndStatusID, dndActionCopyID, dndDropID, dndSelectionID, dndFinishedID, dndAwareID;
+ Atom clipboardID, xSelectionDataID, textID, targetID, incrID;
+ Cursor cursors[UI_CURSOR_COUNT];
+ char *pasteText;
+ XEvent copyEvent;
+#endif
+
+#ifdef UI_WINDOWS
+ HCURSOR cursors[UI_CURSOR_COUNT];
+ HANDLE heap;
+ bool assertionFailure;
+#endif
+
+#ifdef UI_ESSENCE
+ EsInstance *instance;
+
+ void *menuData[256]; // HACK This limits the number of menu items to 128.
+ uintptr_t menuIndex;
+#endif
+
+#ifdef UI_FREETYPE
+ FT_Library ft;
+#endif
+} ui;
+
+UITheme _uiThemeClassic = {
+ .panel1 = 0xFFF0F0F0,
+ .panel2 = 0xFFFFFFFF,
+ .selected = 0xFF94BEFE,
+ .border = 0xFF404040,
+
+ .text = 0xFF000000,
+ .textDisabled = 0xFF404040,
+ .textSelected = 0xFF000000,
+
+ .buttonNormal = 0xFFE0E0E0,
+ .buttonHovered = 0xFFF0F0F0,
+ .buttonPressed = 0xFFA0A0A0,
+ .buttonDisabled = 0xFFF0F0F0,
+
+ .textboxNormal = 0xFFF8F8F8,
+ .textboxFocused = 0xFFFFFFFF,
+
+ .codeFocused = 0xFFE0E0E0,
+ .codeBackground = 0xFFFFFFFF,
+ .codeDefault = 0xFF000000,
+ .codeComment = 0xFFA11F20,
+ .codeString = 0xFF037E01,
+ .codeNumber = 0xFF213EF1,
+ .codeOperator = 0xFF7F0480,
+ .codePreprocessor = 0xFF545D70,
+};
+
+UITheme _uiThemeDark = {
+ .panel1 = 0xFF252B31,
+ .panel2 = 0xFF14181E,
+ .selected = 0xFF94BEFE,
+ .border = 0xFF000000,
+
+ .text = 0xFFFFFFFF,
+ .textDisabled = 0xFF787D81,
+ .textSelected = 0xFF000000,
+
+ .buttonNormal = 0xFF383D41,
+ .buttonHovered = 0xFF4B5874,
+ .buttonPressed = 0xFF0D0D0F,
+ .buttonDisabled = 0xFF1B1F23,
+
+ .textboxNormal = 0xFF31353C,
+ .textboxFocused = 0xFF4D4D59,
+
+ .codeFocused = 0xFF505055,
+ .codeBackground = 0xFF212126,
+ .codeDefault = 0xFFFFFFFF,
+ .codeComment = 0xFFB4B4B4,
+ .codeString = 0xFFF5DDD1,
+ .codeNumber = 0xFFC3F5D3,
+ .codeOperator = 0xFFF5D499,
+ .codePreprocessor = 0xFFF5F3D1,
+};
+
+// Taken from https://commons.wikimedia.org/wiki/File:Codepage-437.png
+// Public domain.
+
+const uint64_t _uiFont[] = {
+ 0x0000000000000000UL, 0x0000000000000000UL, 0xBD8181A5817E0000UL, 0x000000007E818199UL, 0xC3FFFFDBFF7E0000UL, 0x000000007EFFFFE7UL, 0x7F7F7F3600000000UL, 0x00000000081C3E7FUL,
+ 0x7F3E1C0800000000UL, 0x0000000000081C3EUL, 0xE7E73C3C18000000UL, 0x000000003C1818E7UL, 0xFFFF7E3C18000000UL, 0x000000003C18187EUL, 0x3C18000000000000UL, 0x000000000000183CUL,
+ 0xC3E7FFFFFFFFFFFFUL, 0xFFFFFFFFFFFFE7C3UL, 0x42663C0000000000UL, 0x00000000003C6642UL, 0xBD99C3FFFFFFFFFFUL, 0xFFFFFFFFFFC399BDUL, 0x331E4C5870780000UL, 0x000000001E333333UL,
+ 0x3C666666663C0000UL, 0x0000000018187E18UL, 0x0C0C0CFCCCFC0000UL, 0x00000000070F0E0CUL, 0xC6C6C6FEC6FE0000UL, 0x0000000367E7E6C6UL, 0xE73CDB1818000000UL, 0x000000001818DB3CUL,
+ 0x1F7F1F0F07030100UL, 0x000000000103070FUL, 0x7C7F7C7870604000UL, 0x0000000040607078UL, 0x1818187E3C180000UL, 0x0000000000183C7EUL, 0x6666666666660000UL, 0x0000000066660066UL,
+ 0xD8DEDBDBDBFE0000UL, 0x00000000D8D8D8D8UL, 0x6363361C06633E00UL, 0x0000003E63301C36UL, 0x0000000000000000UL, 0x000000007F7F7F7FUL, 0x1818187E3C180000UL, 0x000000007E183C7EUL,
+ 0x1818187E3C180000UL, 0x0000000018181818UL, 0x1818181818180000UL, 0x00000000183C7E18UL, 0x7F30180000000000UL, 0x0000000000001830UL, 0x7F060C0000000000UL, 0x0000000000000C06UL,
+ 0x0303000000000000UL, 0x0000000000007F03UL, 0xFF66240000000000UL, 0x0000000000002466UL, 0x3E1C1C0800000000UL, 0x00000000007F7F3EUL, 0x3E3E7F7F00000000UL, 0x0000000000081C1CUL,
+ 0x0000000000000000UL, 0x0000000000000000UL, 0x18183C3C3C180000UL, 0x0000000018180018UL, 0x0000002466666600UL, 0x0000000000000000UL, 0x36367F3636000000UL, 0x0000000036367F36UL,
+ 0x603E0343633E1818UL, 0x000018183E636160UL, 0x1830634300000000UL, 0x000000006163060CUL, 0x3B6E1C36361C0000UL, 0x000000006E333333UL, 0x000000060C0C0C00UL, 0x0000000000000000UL,
+ 0x0C0C0C0C18300000UL, 0x0000000030180C0CUL, 0x30303030180C0000UL, 0x000000000C183030UL, 0xFF3C660000000000UL, 0x000000000000663CUL, 0x7E18180000000000UL, 0x0000000000001818UL,
+ 0x0000000000000000UL, 0x0000000C18181800UL, 0x7F00000000000000UL, 0x0000000000000000UL, 0x0000000000000000UL, 0x0000000018180000UL, 0x1830604000000000UL, 0x000000000103060CUL,
+ 0xDBDBC3C3663C0000UL, 0x000000003C66C3C3UL, 0x1818181E1C180000UL, 0x000000007E181818UL, 0x0C183060633E0000UL, 0x000000007F630306UL, 0x603C6060633E0000UL, 0x000000003E636060UL,
+ 0x7F33363C38300000UL, 0x0000000078303030UL, 0x603F0303037F0000UL, 0x000000003E636060UL, 0x633F0303061C0000UL, 0x000000003E636363UL, 0x18306060637F0000UL, 0x000000000C0C0C0CUL,
+ 0x633E6363633E0000UL, 0x000000003E636363UL, 0x607E6363633E0000UL, 0x000000001E306060UL, 0x0000181800000000UL, 0x0000000000181800UL, 0x0000181800000000UL, 0x000000000C181800UL,
+ 0x060C183060000000UL, 0x000000006030180CUL, 0x00007E0000000000UL, 0x000000000000007EUL, 0x6030180C06000000UL, 0x00000000060C1830UL, 0x18183063633E0000UL, 0x0000000018180018UL,
+ 0x7B7B63633E000000UL, 0x000000003E033B7BUL, 0x7F6363361C080000UL, 0x0000000063636363UL, 0x663E6666663F0000UL, 0x000000003F666666UL, 0x03030343663C0000UL, 0x000000003C664303UL,
+ 0x66666666361F0000UL, 0x000000001F366666UL, 0x161E1646667F0000UL, 0x000000007F664606UL, 0x161E1646667F0000UL, 0x000000000F060606UL, 0x7B030343663C0000UL, 0x000000005C666363UL,
+ 0x637F636363630000UL, 0x0000000063636363UL, 0x18181818183C0000UL, 0x000000003C181818UL, 0x3030303030780000UL, 0x000000001E333333UL, 0x1E1E366666670000UL, 0x0000000067666636UL,
+ 0x06060606060F0000UL, 0x000000007F664606UL, 0xC3DBFFFFE7C30000UL, 0x00000000C3C3C3C3UL, 0x737B7F6F67630000UL, 0x0000000063636363UL, 0x63636363633E0000UL, 0x000000003E636363UL,
+ 0x063E6666663F0000UL, 0x000000000F060606UL, 0x63636363633E0000UL, 0x000070303E7B6B63UL, 0x363E6666663F0000UL, 0x0000000067666666UL, 0x301C0663633E0000UL, 0x000000003E636360UL,
+ 0x18181899DBFF0000UL, 0x000000003C181818UL, 0x6363636363630000UL, 0x000000003E636363UL, 0xC3C3C3C3C3C30000UL, 0x00000000183C66C3UL, 0xDBC3C3C3C3C30000UL, 0x000000006666FFDBUL,
+ 0x18183C66C3C30000UL, 0x00000000C3C3663CUL, 0x183C66C3C3C30000UL, 0x000000003C181818UL, 0x0C183061C3FF0000UL, 0x00000000FFC38306UL, 0x0C0C0C0C0C3C0000UL, 0x000000003C0C0C0CUL,
+ 0x1C0E070301000000UL, 0x0000000040607038UL, 0x30303030303C0000UL, 0x000000003C303030UL, 0x0000000063361C08UL, 0x0000000000000000UL, 0x0000000000000000UL, 0x0000FF0000000000UL,
+ 0x0000000000180C0CUL, 0x0000000000000000UL, 0x3E301E0000000000UL, 0x000000006E333333UL, 0x66361E0606070000UL, 0x000000003E666666UL, 0x03633E0000000000UL, 0x000000003E630303UL,
+ 0x33363C3030380000UL, 0x000000006E333333UL, 0x7F633E0000000000UL, 0x000000003E630303UL, 0x060F0626361C0000UL, 0x000000000F060606UL, 0x33336E0000000000UL, 0x001E33303E333333UL,
+ 0x666E360606070000UL, 0x0000000067666666UL, 0x18181C0018180000UL, 0x000000003C181818UL, 0x6060700060600000UL, 0x003C666660606060UL, 0x1E36660606070000UL, 0x000000006766361EUL,
+ 0x18181818181C0000UL, 0x000000003C181818UL, 0xDBFF670000000000UL, 0x00000000DBDBDBDBUL, 0x66663B0000000000UL, 0x0000000066666666UL, 0x63633E0000000000UL, 0x000000003E636363UL,
+ 0x66663B0000000000UL, 0x000F06063E666666UL, 0x33336E0000000000UL, 0x007830303E333333UL, 0x666E3B0000000000UL, 0x000000000F060606UL, 0x06633E0000000000UL, 0x000000003E63301CUL,
+ 0x0C0C3F0C0C080000UL, 0x00000000386C0C0CUL, 0x3333330000000000UL, 0x000000006E333333UL, 0xC3C3C30000000000UL, 0x00000000183C66C3UL, 0xC3C3C30000000000UL, 0x0000000066FFDBDBUL,
+ 0x3C66C30000000000UL, 0x00000000C3663C18UL, 0x6363630000000000UL, 0x001F30607E636363UL, 0x18337F0000000000UL, 0x000000007F63060CUL, 0x180E181818700000UL, 0x0000000070181818UL,
+ 0x1800181818180000UL, 0x0000000018181818UL, 0x18701818180E0000UL, 0x000000000E181818UL, 0x000000003B6E0000UL, 0x0000000000000000UL, 0x63361C0800000000UL, 0x00000000007F6363UL,
+};
+
+void _UIWindowEndPaint(UIWindow *window, UIPainter *painter);
+void _UIWindowSetCursor(UIWindow *window, int cursor);
+void _UIWindowGetScreenPosition(UIWindow *window, int *x, int *y);
+void _UIWindowSetPressed(UIWindow *window, UIElement *element, int button);
+void _UIClipboardWriteText(UIWindow *window, char *text);
+char *_UIClipboardReadTextStart(UIWindow *window, size_t *bytes);
+void _UIClipboardReadTextEnd(UIWindow *window, char *text);
+bool _UIMessageLoopSingle(int *result);
+void _UIInspectorRefresh();
+void _UIUpdate();
+
+#ifdef UI_WINDOWS
+void *_UIHeapReAlloc(void *pointer, size_t size);
+#endif
+
+UIRectangle UIRectangleIntersection(UIRectangle a, UIRectangle b) {
+ if (a.l < b.l) a.l = b.l;
+ if (a.t < b.t) a.t = b.t;
+ if (a.r > b.r) a.r = b.r;
+ if (a.b > b.b) a.b = b.b;
+ return a;
+}
+
+UIRectangle UIRectangleBounding(UIRectangle a, UIRectangle b) {
+ if (a.l > b.l) a.l = b.l;
+ if (a.t > b.t) a.t = b.t;
+ if (a.r < b.r) a.r = b.r;
+ if (a.b < b.b) a.b = b.b;
+ return a;
+}
+
+UIRectangle UIRectangleAdd(UIRectangle a, UIRectangle b) {
+ a.l += b.l;
+ a.t += b.t;
+ a.r += b.r;
+ a.b += b.b;
+ return a;
+}
+
+UIRectangle UIRectangleTranslate(UIRectangle a, UIRectangle b) {
+ a.l += b.l;
+ a.t += b.t;
+ a.r += b.l;
+ a.b += b.t;
+ return a;
+}
+
+bool UIRectangleEquals(UIRectangle a, UIRectangle b) {
+ return a.l == b.l && a.r == b.r && a.t == b.t && a.b == b.b;
+}
+
+bool UIRectangleContains(UIRectangle a, int x, int y) {
+ return a.l <= x && a.r > x && a.t <= y && a.b > y;
+}
+
+#include <xmmintrin.h>
+
+typedef union _UIConvertFloatInteger {
+ float f;
+ uint32_t i;
+} _UIConvertFloatInteger;
+
+float _UIFloorFloat(float x) {
+ _UIConvertFloatInteger convert = {x};
+ uint32_t sign = convert.i & 0x80000000;
+ int exponent = (int) ((convert.i >> 23) & 0xFF) - 0x7F;
+
+ if (exponent >= 23) {
+ // There aren't any bits representing a fractional part.
+ } else if (exponent >= 0) {
+ // Positive exponent.
+ uint32_t mask = 0x7FFFFF >> exponent;
+ if (!(mask & convert.i)) return x; // Already an integer.
+ if (sign) convert.i += mask;
+ convert.i &= ~mask; // Mask out the fractional bits.
+ } else if (exponent < 0) {
+ // Negative exponent.
+ return sign ? -1.0 : 0.0;
+ }
+
+ return convert.f;
+}
+
+float _UISquareRootFloat(float x) {
+ float result[4];
+ _mm_storeu_ps(result, _mm_sqrt_ps(_mm_set_ps(0, 0, 0, x)));
+ return result[0];
+}
+
+#define _F(x) (((_UIConvertFloatInteger) { .i = (x) }).f)
+
+float _UIArcTanFloatI(float x) {
+ float x2 = x * x;
+ return x * (_F(0x3F7FFFF8) + x2 * (_F(0xBEAAA53C) + x2 * (_F(0x3E4BC990) + x2 * (_F(0xBE084A60) + x2 * _F(0x3D8864B0)))));
+}
+
+float _UISinFloatI(float x) {
+ float x2 = x * x;
+ return x * (_F(0x3F800000) + x2 * (_F(0xBE2AAAA0) + x2 * (_F(0x3C0882C0) + x2 * _F(0xB94C6000))));
+}
+
+float _UICosFloatI(float x) {
+ float x2 = x * x;
+ return _F(0x3F800000) + x2 * (_F(0xBEFFFFDA) + x2 * (_F(0x3D2A9F60) + x2 * _F(0xBAB22C00)));
+}
+
+#undef _F
+
+float _UISinFloat(float x) {
+ bool negate = false;
+ if (x < 0) { x = -x; negate = true; }
+ x -= 2 * 3.141592654f * _UIFloorFloat(x / (2 * 3.141592654f));
+ if (x < 3.141592654f / 2) {}
+ else if (x < 3.141592654f) { x = 3.141592654f - x; }
+ else if (x < 3 * 3.141592654f / 2) { x = x - 3.141592654f; negate = !negate; }
+ else { x = 3.141592654f * 2 - x; negate = !negate; }
+ float y = x < 3.141592654f / 4 ? _UISinFloatI(x) : _UICosFloatI(3.141592654f / 2 - x);
+ return negate ? -y : y;
+}
+
+float _UICosFloat(float x) {
+ return _UISinFloat(3.141592654f / 2 - x);
+}
+
+float _UIArcTanFloat(float x) {
+ bool negate = false, reciprocalTaken = false;
+ if (x < 0) { x = -x; negate = true; }
+ if (x > 1) { x = 1 / x; reciprocalTaken = true; }
+ float y = x < 0.5f ? _UIArcTanFloatI(x) : (0.463647609f + _UIArcTanFloatI((2 * x - 1) / (2 + x)));
+ if (reciprocalTaken) { y = 3.141592654f / 2 - y; }
+ return negate ? -y : y;
+}
+
+float _UIArcTan2Float(float y, float x) {
+ if (x == 0) return y > 0 ? 3.141592654f / 2 : -3.141592654f / 2;
+ else if (x > 0) return _UIArcTanFloat(y / x);
+ else if (y >= 0) return 3.141592654f + _UIArcTanFloat(y / x);
+ else return -3.141592654f + _UIArcTanFloat(y / x);
+}
+
+float _UILinearMap(float value, float inFrom, float inTo, float outFrom, float outTo) {
+ float inRange = inTo - inFrom, outRange = outTo - outFrom;
+ float normalisedValue = (value - inFrom) / inRange;
+ return normalisedValue * outRange + outFrom;
+}
+
+bool UIColorToHSV(uint32_t rgb, float *hue, float *saturation, float *value) {
+ float r = UI_COLOR_RED_F(rgb);
+ float g = UI_COLOR_GREEN_F(rgb);
+ float b = UI_COLOR_BLUE_F(rgb);
+
+ float maximum = (r > g && r > b) ? r : (g > b ? g : b),
+ minimum = (r < g && r < b) ? r : (g < b ? g : b),
+ difference = maximum - minimum;
+ *value = maximum;
+
+ if (!difference) {
+ *saturation = 0;
+ return false;
+ } else {
+ if (r == maximum) *hue = (g - b) / difference + 0;
+ if (g == maximum) *hue = (b - r) / difference + 2;
+ if (b == maximum) *hue = (r - g) / difference + 4;
+ if (*hue < 0) *hue += 6;
+ *saturation = difference / maximum;
+ return true;
+ }
+}
+
+void UIColorToRGB(float h, float s, float v, uint32_t *rgb) {
+ float r, g, b;
+
+ if (!s) {
+ r = g = b = v;
+ } else {
+ int h0 = ((int) h) % 6;
+ float f = h - _UIFloorFloat(h);
+ float x = v * (1 - s), y = v * (1 - s * f), z = v * (1 - s * (1 - f));
+
+ switch (h0) {
+ case 0: r = v, g = z, b = x; break;
+ case 1: r = y, g = v, b = x; break;
+ case 2: r = x, g = v, b = z; break;
+ case 3: r = x, g = y, b = v; break;
+ case 4: r = z, g = x, b = v; break;
+ default: r = v, g = x, b = y; break;
+ }
+ }
+
+ *rgb = UI_COLOR_FROM_FLOAT(r, g, b);
+}
+
+void UIElementRefresh(UIElement *element) {
+ UIElementMessage(element, UI_MSG_LAYOUT, 0, 0);
+ UIElementRepaint(element, NULL);
+}
+
+void UIElementRepaint(UIElement *element, UIRectangle *region) {
+ if (!region) {
+ region = &element->bounds;
+ }
+
+ UIRectangle r = UIRectangleIntersection(*region, element->clip);
+
+ if (!UI_RECT_VALID(r)) {
+ return;
+ }
+
+ if (UI_RECT_VALID(element->window->updateRegion)) {
+ element->window->updateRegion = UIRectangleBounding(element->window->updateRegion, r);
+ } else {
+ element->window->updateRegion = r;
+ }
+}
+
+bool UIElementAnimate(UIElement *element, bool stop) {
+ if (stop) {
+ if (ui.animating != element) {
+ return false;
+ }
+
+ ui.animating = NULL;
+ } else {
+ if (ui.animating && ui.animating != element) {
+ return false;
+ }
+
+ ui.animating = element;
+ }
+
+ return true;
+}
+
+uint64_t UIAnimateClock() {
+ return (uint64_t) UI_CLOCK() * 1000 / UI_CLOCKS_PER_SECOND;
+}
+
+void _UIElementDestroyDescendents(UIElement *element, bool topLevel) {
+ UIElement *child = element->children;
+
+ while (child) {
+ if (!topLevel || (~child->flags & UI_ELEMENT_NON_CLIENT)) {
+ UIElementDestroy(child);
+ }
+
+ child = child->next;
+ }
+
+#ifdef UI_DEBUG
+ _UIInspectorRefresh();
+#endif
+}
+
+void UIElementDestroyDescendents(UIElement *element) {
+ _UIElementDestroyDescendents(element, true);
+}
+
+void UIElementDestroy(UIElement *element) {
+ if (element->flags & UI_ELEMENT_DESTROY) {
+ return;
+ }
+
+ element->flags |= UI_ELEMENT_DESTROY | UI_ELEMENT_HIDE;
+
+ UIElement *ancestor = element->parent;
+
+ while (ancestor) {
+ ancestor->flags |= UI_ELEMENT_DESTROY_DESCENDENT;
+ ancestor = ancestor->parent;
+ }
+
+ _UIElementDestroyDescendents(element, false);
+}
+
+void UIDrawBlock(UIPainter *painter, UIRectangle rectangle, uint32_t color) {
+ rectangle = UIRectangleIntersection(painter->clip, rectangle);
+
+ if (!UI_RECT_VALID(rectangle)) {
+ return;
+ }
+
+#ifdef UI_SSE2
+ __m128i color4 = _mm_set_epi32(color, color, color, color);
+#endif
+
+ for (int line = rectangle.t; line < rectangle.b; line++) {
+ uint32_t *bits = painter->bits + line * painter->width + rectangle.l;
+ int count = UI_RECT_WIDTH(rectangle);
+
+#ifdef UI_SSE2
+ while (count >= 4) {
+ _mm_storeu_si128((__m128i *) bits, color4);
+ bits += 4;
+ count -= 4;
+ }
+#endif
+
+ while (count--) {
+ *bits++ = color;
+ }
+ }
+
+#ifdef UI_DEBUG
+ painter->fillCount += UI_RECT_WIDTH(rectangle) * UI_RECT_HEIGHT(rectangle);
+#endif
+}
+
+bool UIDrawLine(UIPainter *painter, int x0, int y0, int x1, int y1, uint32_t color) {
+ // Apply the clip.
+
+ UIRectangle c = painter->clip;
+ if (!UI_RECT_VALID(c)) return false;
+ int dx = x1 - x0, dy = y1 - y0;
+ const int p[4] = { -dx, dx, -dy, dy };
+ const int q[4] = { x0 - c.l, c.r - 1 - x0, y0 - c.t, c.b - 1 - y0 };
+ float t0 = 0.0f, t1 = 1.0f; // How far along the line the points end up.
+
+ for (int i = 0; i < 4; i++) {
+ if (!p[i] && q[i] < 0) return false;
+ float r = (float) q[i] / p[i];
+ if (p[i] < 0 && r > t1) return false;
+ if (p[i] > 0 && r < t0) return false;
+ if (p[i] < 0 && r > t0) t0 = r;
+ if (p[i] > 0 && r < t1) t1 = r;
+ }
+
+ x1 = x0 + t1 * dx, y1 = y0 + t1 * dy;
+ x0 += t0 * dx, y0 += t0 * dy;
+
+ // Calculate the delta X and delta Y.
+
+ if (y1 < y0) {
+ int t;
+ t = x0, x0 = x1, x1 = t;
+ t = y0, y0 = y1, y1 = t;
+ }
+
+ dx = x1 - x0, dy = y1 - y0;
+ int dxs = dx < 0 ? -1 : 1;
+ if (dx < 0) dx = -dx;
+
+ // Draw the line using Bresenham's line algorithm.
+
+ uint32_t *bits = painter->bits + y0 * painter->width + x0;
+
+ if (dy * dy < dx * dx) {
+ int m = 2 * dy - dx;
+
+ for (int i = 0; i < dx; i++, bits += dxs) {
+ *bits = color;
+ if (m > 0) bits += painter->width, m -= 2 * dx;
+ m += 2 * dy;
+ }
+ } else {
+ int m = 2 * dx - dy;
+
+ for (int i = 0; i < dy; i++, bits += painter->width) {
+ *bits = color;
+ if (m > 0) bits += dxs, m -= 2 * dy;
+ m += 2 * dx;
+ }
+ }
+
+ return true;
+}
+
+void UIDrawTriangle(UIPainter *painter, int x0, int y0, int x1, int y1, int x2, int y2, uint32_t color) {
+ // Step 1: Sort the points by their y-coordinate.
+ if (y1 < y0) { int xt = x0; x0 = x1, x1 = xt; int yt = y0; y0 = y1, y1 = yt; }
+ if (y2 < y1) { int xt = x1; x1 = x2, x2 = xt; int yt = y1; y1 = y2, y2 = yt; }
+ if (y1 < y0) { int xt = x0; x0 = x1, x1 = xt; int yt = y0; y0 = y1, y1 = yt; }
+ if (y2 == y0) return;
+
+ // Step 2: Clip the triangle.
+ if (x0 < painter->clip.l && x1 < painter->clip.l && x2 < painter->clip.l) return;
+ if (x0 >= painter->clip.r && x1 >= painter->clip.r && x2 >= painter->clip.r) return;
+ if (y2 < painter->clip.t || y0 >= painter->clip.b) return;
+ bool needsXClip = x0 < painter->clip.l + 1 || x0 >= painter->clip.r - 1
+ || x1 < painter->clip.l + 1 || x1 >= painter->clip.r - 1
+ || x2 < painter->clip.l + 1 || x2 >= painter->clip.r - 1;
+ bool needsYClip = y0 < painter->clip.t + 1 || y2 >= painter->clip.b - 1;
+#define _UI_DRAW_TRIANGLE_APPLY_CLIP(xo, yo) \
+ if (needsYClip && (yi + yo < painter->clip.t || yi + yo >= painter->clip.b)) continue; \
+ if (needsXClip && xf + xo < painter->clip.l) xf = painter->clip.l - xo; \
+ if (needsXClip && xt + xo > painter->clip.r) xt = painter->clip.r - xo;
+
+ // Step 3: Split into 2 triangles with bases aligned with the x-axis.
+ float xm0 = (x2 - x0) * (y1 - y0) / (y2 - y0), xm1 = x1 - x0;
+ if (xm1 < xm0) { float xmt = xm0; xm0 = xm1, xm1 = xmt; }
+ float xe0 = xm0 + x0 - x2, xe1 = xm1 + x0 - x2;
+ int ym = y1 - y0, ye = y2 - y1;
+ float ymr = 1.0f / ym, yer = 1.0f / ye;
+
+ // Step 4: Draw the top part.
+ for (float y = 0; y < ym; y++) {
+ int xf = xm0 * y * ymr, xt = xm1 * y * ymr, yi = (int) y;
+ _UI_DRAW_TRIANGLE_APPLY_CLIP(x0, y0);
+ uint32_t *b = &painter->bits[(yi + y0) * painter->width + x0];
+ for (int x = xf; x < xt; x++) b[x] = color;
+ }
+
+ // Step 5: Draw the bottom part.
+ for (float y = 0; y < ye; y++) {
+ int xf = xe0 * (ye - y) * yer, xt = xe1 * (ye - y) * yer, yi = (int) y;
+ _UI_DRAW_TRIANGLE_APPLY_CLIP(x2, y1);
+ uint32_t *b = &painter->bits[(yi + y1) * painter->width + x2];
+ for (int x = xf; x < xt; x++) b[x] = color;
+ }
+}
+
+void UIDrawTriangleOutline(UIPainter *painter, int x0, int y0, int x1, int y1, int x2, int y2, uint32_t color) {
+ UIDrawLine(painter, x0, y0, x1, y1, color);
+ UIDrawLine(painter, x1, y1, x2, y2, color);
+ UIDrawLine(painter, x2, y2, x0, y0, color);
+}
+
+void UIDrawInvert(UIPainter *painter, UIRectangle rectangle) {
+ rectangle = UIRectangleIntersection(painter->clip, rectangle);
+
+ if (!UI_RECT_VALID(rectangle)) {
+ return;
+ }
+
+ for (int line = rectangle.t; line < rectangle.b; line++) {
+ uint32_t *bits = painter->bits + line * painter->width + rectangle.l;
+ int count = UI_RECT_WIDTH(rectangle);
+
+ while (count--) {
+ uint32_t in = *bits;
+ *bits = in ^ 0xFFFFFF;
+ bits++;
+ }
+ }
+}
+
+void UIDrawGlyph(UIPainter *painter, int x0, int y0, int c, uint32_t color) {
+#ifdef UI_FREETYPE
+ UIFont *font = ui.activeFont;
+
+ if (font->isFreeType) {
+ if (c < 0 || c > 127) c = '?';
+ if (c == '\r') c = ' ';
+
+ if (!font->glyphsRendered[c]) {
+ FT_Load_Char(font->font, c == 24 ? 0x2191 : c == 25 ? 0x2193 : c == 26 ? 0x2192 : c == 27 ? 0x2190 : c, FT_LOAD_DEFAULT);
+#ifdef UI_FREETYPE_SUBPIXEL
+ FT_Render_Glyph(font->font->glyph, FT_RENDER_MODE_LCD);
+#else
+ FT_Render_Glyph(font->font->glyph, FT_RENDER_MODE_NORMAL);
+#endif
+ FT_Bitmap_Copy(ui.ft, &font->font->glyph->bitmap, &font->glyphs[c]);
+ font->glyphOffsetsX[c] = font->font->glyph->bitmap_left;
+ font->glyphOffsetsY[c] = font->font->size->metrics.ascender / 64 - font->font->glyph->bitmap_top;
+ font->glyphsRendered[c] = true;
+ }
+
+ FT_Bitmap *bitmap = &font->glyphs[c];
+ x0 += font->glyphOffsetsX[c], y0 += font->glyphOffsetsY[c];
+
+ for (int y = 0; y < (int) bitmap->rows; y++) {
+ if (y0 + y < painter->clip.t) continue;
+ if (y0 + y >= painter->clip.b) break;
+
+ int width = bitmap->width;
+#ifdef UI_FREETYPE_SUBPIXEL
+ width /= 3;
+#endif
+
+ for (int x = 0; x < width; x++) {
+ if (x0 + x < painter->clip.l) continue;
+ if (x0 + x >= painter->clip.r) break;
+
+ uint32_t *destination = painter->bits + (x0 + x) + (y0 + y) * painter->width;
+ uint32_t original = *destination;
+
+#ifdef UI_FREETYPE_SUBPIXEL
+ uint32_t ra = ((uint8_t *) bitmap->buffer)[x * 3 + y * bitmap->pitch + 0];
+ uint32_t ga = ((uint8_t *) bitmap->buffer)[x * 3 + y * bitmap->pitch + 1];
+ uint32_t ba = ((uint8_t *) bitmap->buffer)[x * 3 + y * bitmap->pitch + 2];
+ ra += (ga - ra) / 2, ba += (ga - ba) / 2;
+#else
+ uint32_t ra = ((uint8_t *) bitmap->buffer)[x + y * bitmap->pitch];
+ uint32_t ga = ra, ba = ra;
+#endif
+ uint32_t r2 = (255 - ra) * ((original & 0x000000FF) >> 0);
+ uint32_t g2 = (255 - ga) * ((original & 0x0000FF00) >> 8);
+ uint32_t b2 = (255 - ba) * ((original & 0x00FF0000) >> 16);
+ uint32_t r1 = ra * ((color & 0x000000FF) >> 0);
+ uint32_t g1 = ga * ((color & 0x0000FF00) >> 8);
+ uint32_t b1 = ba * ((color & 0x00FF0000) >> 16);
+
+ uint32_t result = 0xFF000000 | (0x00FF0000 & ((b1 + b2) << 8))
+ | (0x0000FF00 & ((g1 + g2) << 0))
+ | (0x000000FF & ((r1 + r2) >> 8));
+ *destination = result;
+ }
+ }
+
+ return;
+ }
+#endif
+
+ if (c < 0 || c > 127) c = '?';
+
+ UIRectangle rectangle = UIRectangleIntersection(painter->clip, UI_RECT_4(x0, x0 + 8, y0, y0 + 16));
+
+ const uint8_t *data = (const uint8_t *) _uiFont + c * 16;
+
+ for (int i = rectangle.t; i < rectangle.b; i++) {
+ uint32_t *bits = painter->bits + i * painter->width + rectangle.l;
+ uint8_t byte = data[i - y0];
+
+ for (int j = rectangle.l; j < rectangle.r; j++) {
+ if (byte & (1 << (j - x0))) {
+ *bits = color;
+ }
+
+ bits++;
+ }
+ }
+}
+
+ptrdiff_t _UIStringLength(const char *cString) {
+ if (!cString) return 0;
+ ptrdiff_t length;
+ for (length = 0; cString[length]; length++);
+ return length;
+}
+
+char *UIStringCopy(const char *in, ptrdiff_t inBytes) {
+ if (inBytes == -1) {
+ inBytes = _UIStringLength(in);
+ }
+
+ char *buffer = (char *) UI_MALLOC(inBytes + 1);
+
+ for (intptr_t i = 0; i < inBytes; i++) {
+ buffer[i] = in[i];
+ }
+
+ buffer[inBytes] = 0;
+ return buffer;
+}
+
+int UIMeasureStringWidth(const char *string, ptrdiff_t bytes) {
+ if (bytes == -1) {
+ bytes = _UIStringLength(string);
+ }
+
+ return bytes * ui.activeFont->glyphWidth;
+}
+
+int UIMeasureStringHeight() {
+ return ui.activeFont->glyphHeight;
+}
+
+void UIDrawString(UIPainter *painter, UIRectangle r, const char *string, ptrdiff_t bytes, uint32_t color, int align, UIStringSelection *selection) {
+ UIRectangle oldClip = painter->clip;
+ painter->clip = UIRectangleIntersection(r, oldClip);
+
+ if (!UI_RECT_VALID(painter->clip)) {
+ painter->clip = oldClip;
+ return;
+ }
+
+ if (bytes == -1) {
+ bytes = _UIStringLength(string);
+ }
+
+ int width = UIMeasureStringWidth(string, bytes);
+ int height = UIMeasureStringHeight();
+ int x = align == UI_ALIGN_CENTER ? ((r.l + r.r - width) / 2) : align == UI_ALIGN_RIGHT ? (r.r - width) : r.l;
+ int y = (r.t + r.b - height) / 2;
+ int i = 0, j = 0;
+
+ int selectFrom = -1, selectTo = -1;
+
+ if (selection) {
+ selectFrom = selection->carets[0];
+ selectTo = selection->carets[1];
+
+ if (selectFrom > selectTo) {
+ UI_SWAP(int, selectFrom, selectTo);
+ }
+ }
+
+ for (; j < bytes; j++) {
+ char c = *string++;
+ uint32_t colorText = color;
+
+ if (j >= selectFrom && j < selectTo) {
+ UIDrawBlock(painter, UI_RECT_4(x, x + ui.activeFont->glyphWidth, y, y + height), selection->colorBackground);
+ colorText = selection->colorText;
+ }
+
+ if (c != '\t') {
+ UIDrawGlyph(painter, x, y, c, colorText);
+ }
+
+ if (selection && selection->carets[0] == j) {
+ UIDrawInvert(painter, UI_RECT_4(x, x + 1, y, y + height));
+ }
+
+ x += ui.activeFont->glyphWidth, i++;
+
+ if (c == '\t') {
+ while (i & 3) x += ui.activeFont->glyphWidth, i++;
+ }
+ }
+
+ if (selection && selection->carets[0] == j) {
+ UIDrawInvert(painter, UI_RECT_4(x, x + 1, y, y + height));
+ }
+
+ painter->clip = oldClip;
+}
+
+void UIDrawBorder(UIPainter *painter, UIRectangle r, uint32_t borderColor, UIRectangle borderSize) {
+ UIDrawBlock(painter, UI_RECT_4(r.l, r.r, r.t, r.t + borderSize.t), borderColor);
+ UIDrawBlock(painter, UI_RECT_4(r.l, r.l + borderSize.l, r.t + borderSize.t, r.b - borderSize.b), borderColor);
+ UIDrawBlock(painter, UI_RECT_4(r.r - borderSize.r, r.r, r.t + borderSize.t, r.b - borderSize.b), borderColor);
+ UIDrawBlock(painter, UI_RECT_4(r.l, r.r, r.b - borderSize.b, r.b), borderColor);
+}
+
+void UIDrawRectangle(UIPainter *painter, UIRectangle r, uint32_t mainColor, uint32_t borderColor, UIRectangle borderSize) {
+ UIDrawBorder(painter, r, borderColor, borderSize);
+ UIDrawBlock(painter, UI_RECT_4(r.l + borderSize.l, r.r - borderSize.r, r.t + borderSize.t, r.b - borderSize.b), mainColor);
+}
+
+void UIElementMove(UIElement *element, UIRectangle bounds, bool alwaysLayout) {
+ UIRectangle oldClip = element->clip;
+ element->clip = UIRectangleIntersection(element->parent->clip, bounds);
+
+ if (!UIRectangleEquals(element->bounds, bounds) || !UIRectangleEquals(element->clip, oldClip) || alwaysLayout) {
+ element->bounds = bounds;
+ UIElementMessage(element, UI_MSG_LAYOUT, 0, 0);
+ }
+}
+
+int UIElementMessage(UIElement *element, UIMessage message, int di, void *dp) {
+ if (message != UI_MSG_DESTROY && (element->flags & UI_ELEMENT_DESTROY)) {
+ return 0;
+ }
+
+ if (message >= UI_MSG_INPUT_EVENTS_START && message <= UI_MSG_INPUT_EVENTS_END && (element->flags & UI_ELEMENT_DISABLED)) {
+ return 0;
+ }
+
+ if (element->messageUser) {
+ int result = element->messageUser(element, message, di, dp);
+
+ if (result) {
+ return result;
+ }
+ }
+
+ if (element->messageClass) {
+ return element->messageClass(element, message, di, dp);
+ } else {
+ return 0;
+ }
+}
+
+void UIElementChangeParent(UIElement *element, UIElement *newParent, UIElement *insertBefore) {
+ UIElement **link = &element->parent->children;
+
+ while (true) {
+ if (*link == element) {
+ *link = element->next;
+ break;
+ } else {
+ link = &(*link)->next;
+ }
+ }
+
+ link = &newParent->children;
+ element->next = insertBefore;
+
+ while (true) {
+ if ((*link) == insertBefore) {
+ *link = element;
+ break;
+ } else {
+ link = &(*link)->next;
+ }
+ }
+
+ element->parent = newParent;
+ element->window = newParent->window;
+}
+
+UIElement *UIElementCreate(size_t bytes, UIElement *parent, uint32_t flags, int (*message)(UIElement *, UIMessage, int, void *), const char *cClassName) {
+ UI_ASSERT(bytes >= sizeof(UIElement));
+ UIElement *element = (UIElement *) UI_CALLOC(bytes);
+ element->flags = flags;
+ element->messageClass = message;
+
+ if (!parent && (~flags & UI_ELEMENT_WINDOW)) {
+ UI_ASSERT(ui.parentStackCount);
+ parent = ui.parentStack[ui.parentStackCount - 1];
+ }
+
+ if ((~flags & UI_ELEMENT_NON_CLIENT) && parent) {
+ UIElementMessage(parent, UI_MSG_CLIENT_PARENT, 0, &parent);
+ }
+
+ if (parent) {
+ element->window = parent->window;
+ element->parent = parent;
+
+ if (parent->children) {
+ UIElement *sibling = parent->children;
+
+ while (sibling->next) {
+ sibling = sibling->next;
+ }
+
+ sibling->next = element;
+ } else {
+ parent->children = element;
+ }
+
+ UI_ASSERT(~parent->flags & UI_ELEMENT_DESTROY);
+ }
+
+ element->cClassName = cClassName;
+ static uint32_t id = 0;
+ element->id = ++id;
+
+#ifdef UI_DEBUG
+ _UIInspectorRefresh();
+#endif
+
+ if (flags & UI_ELEMENT_PARENT_PUSH) {
+ UIParentPush(element);
+ }
+
+ return element;
+}
+
+UIElement *UIParentPush(UIElement *element) {
+ UI_ASSERT(ui.parentStackCount != sizeof(ui.parentStack) / sizeof(ui.parentStack[0]));
+ ui.parentStack[ui.parentStackCount++] = element;
+ return element;
+}
+
+UIElement *UIParentPop() {
+ UI_ASSERT(ui.parentStackCount);
+ ui.parentStackCount--;
+ return ui.parentStack[ui.parentStackCount];
+}
+
+int _UIPanelMeasure(UIPanel *panel) {
+ bool horizontal = panel->e.flags & UI_PANEL_HORIZONTAL;
+ int size = 0;
+ UIElement *child = panel->e.children;
+
+ while (child) {
+ if (~child->flags & UI_ELEMENT_HIDE) {
+ if (horizontal) {
+ int height = UIElementMessage(child, UI_MSG_GET_HEIGHT, 0, 0);
+
+ if (height > size) {
+ size = height;
+ }
+ } else {
+ int width = UIElementMessage(child, UI_MSG_GET_WIDTH, 0, 0);
+
+ if (width > size) {
+ size = width;
+ }
+ }
+ }
+
+ child = child->next;
+ }
+
+ int border = 0;
+
+ if (horizontal) {
+ border = panel->border.t + panel->border.b;
+ } else {
+ border = panel->border.l + panel->border.r;
+ }
+
+ return size + border * panel->e.window->scale;
+}
+
+int _UIPanelLayout(UIPanel *panel, UIRectangle bounds, bool measure) {
+ bool horizontal = panel->e.flags & UI_PANEL_HORIZONTAL;
+ float scale = panel->e.window->scale;
+ int position = (horizontal ? panel->border.l : panel->border.t) * scale;
+ if (panel->scrollBar && !measure) position -= panel->scrollBar->position;
+ int hSpace = UI_RECT_WIDTH(bounds) - UI_RECT_TOTAL_H(panel->border) * scale;
+ int vSpace = UI_RECT_HEIGHT(bounds) - UI_RECT_TOTAL_V(panel->border) * scale;
+
+ int available = horizontal ? hSpace : vSpace;
+ int fill = 0, count = 0, perFill = 0;
+
+ for (UIElement *child = panel->e.children; child; child = child->next) {
+ if (child->flags & (UI_ELEMENT_HIDE | UI_ELEMENT_NON_CLIENT)) {
+ continue;
+ }
+
+ count++;
+
+ if (horizontal) {
+ if (child->flags & UI_ELEMENT_H_FILL) {
+ fill++;
+ } else if (available > 0) {
+ available -= UIElementMessage(child, UI_MSG_GET_WIDTH, vSpace, 0);
+ }
+ } else {
+ if (child->flags & UI_ELEMENT_V_FILL) {
+ fill++;
+ } else if (available > 0) {
+ available -= UIElementMessage(child, UI_MSG_GET_HEIGHT, hSpace, 0);
+ }
+ }
+ }
+
+ if (count) {
+ available -= (count - 1) * (int) (panel->gap * scale);
+ }
+
+ if (available > 0 && fill) {
+ perFill = available / fill;
+ }
+
+ bool expand = panel->e.flags & UI_PANEL_EXPAND;
+ int scaledBorder2 = (horizontal ? panel->border.t : panel->border.l) * panel->e.window->scale;
+
+ for (UIElement *child = panel->e.children; child; child = child->next) {
+ if (child->flags & (UI_ELEMENT_HIDE | UI_ELEMENT_NON_CLIENT)) {
+ continue;
+ }
+
+ if (horizontal) {
+ int height = ((child->flags & UI_ELEMENT_V_FILL) || expand) ? vSpace : UIElementMessage(child, UI_MSG_GET_HEIGHT, 0, 0);
+ int width = (child->flags & UI_ELEMENT_H_FILL) ? perFill : UIElementMessage(child, UI_MSG_GET_WIDTH, height, 0);
+ UIRectangle relative = UI_RECT_4(position, position + width,
+ scaledBorder2 + (vSpace - height) / 2,
+ scaledBorder2 + (vSpace + height) / 2);
+ if (!measure) UIElementMove(child, UIRectangleTranslate(relative, bounds), false);
+ position += width + panel->gap * scale;
+ } else {
+ int width = ((child->flags & UI_ELEMENT_H_FILL) || expand) ? hSpace : UIElementMessage(child, UI_MSG_GET_WIDTH, 0, 0);
+ int height = (child->flags & UI_ELEMENT_V_FILL) ? perFill : UIElementMessage(child, UI_MSG_GET_HEIGHT, width, 0);
+ UIRectangle relative = UI_RECT_4(scaledBorder2 + (hSpace - width) / 2,
+ scaledBorder2 + (hSpace + width) / 2, position, position + height);
+ if (!measure) UIElementMove(child, UIRectangleTranslate(relative, bounds), false);
+ position += height + panel->gap * scale;
+ }
+ }
+
+ return position - panel->gap * scale + (horizontal ? panel->border.r : panel->border.b) * scale;
+}
+
+int _UIPanelMessage(UIElement *element, UIMessage message, int di, void *dp) {
+ UIPanel *panel = (UIPanel *) element;
+ bool horizontal = element->flags & UI_PANEL_HORIZONTAL;
+
+ if (message == UI_MSG_LAYOUT) {
+ int scrollBarWidth = panel->scrollBar ? (UI_SIZE_SCROLL_BAR * element->window->scale) : 0;
+ UIRectangle bounds = element->bounds;
+ bounds.r -= scrollBarWidth;
+
+ if (panel->scrollBar) {
+ UIRectangle scrollBarBounds = element->bounds;
+ scrollBarBounds.l = scrollBarBounds.r - scrollBarWidth;
+ panel->scrollBar->maximum = _UIPanelLayout(panel, bounds, true);
+ panel->scrollBar->page = UI_RECT_HEIGHT(element->bounds);
+ UIElementMove(&panel->scrollBar->e, scrollBarBounds, true);
+ }
+
+ _UIPanelLayout(panel, bounds, false);
+ } else if (message == UI_MSG_GET_WIDTH) {
+ if (horizontal) {
+ return _UIPanelLayout(panel, UI_RECT_4(0, 0, 0, di), true);
+ } else {
+ return _UIPanelMeasure(panel);
+ }
+ } else if (message == UI_MSG_GET_HEIGHT) {
+ if (horizontal) {
+ return _UIPanelMeasure(panel);
+ } else {
+ int width = di && panel->scrollBar ? (di - UI_SIZE_SCROLL_BAR * element->window->scale) : di;
+ return _UIPanelLayout(panel, UI_RECT_4(0, width, 0, 0), true);
+ }
+ } else if (message == UI_MSG_PAINT) {
+ if (element->flags & UI_PANEL_GRAY) {
+ UIDrawBlock((UIPainter *) dp, element->bounds, ui.theme.panel1);
+ } else if (element->flags & UI_PANEL_WHITE) {
+ UIDrawBlock((UIPainter *) dp, element->bounds, ui.theme.panel2);
+ }
+
+ if (element->flags & UI_PANEL_BORDER) {
+ UIDrawBorder((UIPainter *) dp, element->bounds, ui.theme.border, UI_RECT_1((int) element->window->scale));
+ }
+ } else if (message == UI_MSG_MOUSE_WHEEL && panel->scrollBar) {
+ return UIElementMessage(&panel->scrollBar->e, message, di, dp);
+ } else if (message == UI_MSG_SCROLLED) {
+ UIElementRefresh(element);
+ }
+
+ return 0;
+}
+
+UIPanel *UIPanelCreate(UIElement *parent, uint32_t flags) {
+ UIPanel *panel = (UIPanel *) UIElementCreate(sizeof(UIPanel), parent, flags, _UIPanelMessage, "Panel");
+
+ if (flags & UI_PANEL_MEDIUM_SPACING) {
+ panel->border = UI_RECT_1(UI_SIZE_PANE_MEDIUM_BORDER);
+ panel->gap = UI_SIZE_PANE_MEDIUM_GAP;
+ } else if (flags & UI_PANEL_SMALL_SPACING) {
+ panel->border = UI_RECT_1(UI_SIZE_PANE_SMALL_BORDER);
+ panel->gap = UI_SIZE_PANE_SMALL_GAP;
+ }
+
+ if (flags & UI_PANEL_SCROLL) {
+ panel->scrollBar = UIScrollBarCreate(&panel->e, UI_ELEMENT_NON_CLIENT);
+ }
+
+ return panel;
+}
+
+void _UIWrapPanelLayoutRow(UIWrapPanel *panel, UIElement *child, UIElement *rowEnd, int rowY, int rowHeight) {
+ int rowPosition = 0;
+
+ while (child != rowEnd) {
+ int height = UIElementMessage(child, UI_MSG_GET_HEIGHT, 0, 0);
+ int width = UIElementMessage(child, UI_MSG_GET_WIDTH, 0, 0);
+ UIRectangle relative = UI_RECT_4(rowPosition, rowPosition + width, rowY + rowHeight / 2 - height / 2, rowY + rowHeight / 2 + height / 2);
+ UIElementMove(child, UIRectangleTranslate(relative, panel->e.bounds), false);
+ child = child->next;
+ rowPosition += width;
+ }
+}
+
+int _UIWrapPanelMessage(UIElement *element, UIMessage message, int di, void *dp) {
+ UIWrapPanel *panel = (UIWrapPanel *) element;
+ bool horizontal = element->flags & UI_PANEL_HORIZONTAL;
+
+ if (message == UI_MSG_LAYOUT || message == UI_MSG_GET_HEIGHT) {
+ int totalHeight = 0;
+ int rowPosition = 0;
+ int rowHeight = 0;
+ int rowLimit = message == UI_MSG_LAYOUT ? UI_RECT_WIDTH(element->bounds) : di;
+
+ UIElement *child = panel->e.children;
+ UIElement *rowStart = child;
+
+ while (child) {
+ if (~child->flags & UI_ELEMENT_HIDE) {
+ int height = UIElementMessage(child, UI_MSG_GET_HEIGHT, 0, 0);
+ int width = UIElementMessage(child, UI_MSG_GET_WIDTH, 0, 0);
+
+ if (rowLimit && rowPosition + width > rowLimit) {
+ _UIWrapPanelLayoutRow(panel, rowStart, child, totalHeight, rowHeight);
+ totalHeight += rowHeight;
+ rowPosition = rowHeight = 0;
+ rowStart = child;
+ }
+
+ if (height > rowHeight) {
+ rowHeight = height;
+ }
+
+ rowPosition += width;
+ }
+
+ child = child->next;
+ }
+
+ if (message == UI_MSG_GET_HEIGHT) {
+ return totalHeight + rowHeight;
+ } else {
+ _UIWrapPanelLayoutRow(panel, rowStart, child, totalHeight, rowHeight);
+ }
+ }
+
+ return 0;
+}
+
+UIWrapPanel *UIWrapPanelCreate(UIElement *parent, uint32_t flags) {
+ return (UIWrapPanel *) UIElementCreate(sizeof(UIWrapPanel), parent, flags, _UIWrapPanelMessage, "Wrap Panel");
+}
+
+void _UIButtonCalculateColors(UIElement *element, uint32_t *color, uint32_t *textColor) {
+ bool disabled = element->flags & UI_ELEMENT_DISABLED;
+ bool focused = element == element->window->focused;
+ bool pressed = element == element->window->pressed;
+ bool hovered = element == element->window->hovered;
+ *color = disabled ? ui.theme.buttonDisabled
+ : (pressed && hovered) ? ui.theme.buttonPressed
+ : (pressed || hovered) ? ui.theme.buttonHovered
+ : focused ? ui.theme.selected : ui.theme.buttonNormal;
+ *textColor = disabled ? ui.theme.textDisabled
+ : *color == ui.theme.selected ? ui.theme.textSelected : ui.theme.text;
+}
+
+
+int _UIButtonMessage(UIElement *element, UIMessage message, int di, void *dp) {
+ UIButton *button = (UIButton *) element;
+ bool isMenuItem = element->flags & UI_BUTTON_MENU_ITEM;
+ bool isDropDown = element->flags & UI_BUTTON_DROP_DOWN;
+
+ if (message == UI_MSG_GET_HEIGHT) {
+ if (isMenuItem) {
+ return UI_SIZE_MENU_ITEM_HEIGHT * element->window->scale;
+ } else {
+ return UI_SIZE_BUTTON_HEIGHT * element->window->scale;
+ }
+ } else if (message == UI_MSG_GET_WIDTH) {
+ int labelSize = UIMeasureStringWidth(button->label, button->labelBytes);
+ int paddedSize = labelSize + UI_SIZE_BUTTON_PADDING * element->window->scale;
+ if (isDropDown) paddedSize += ui.activeFont->glyphWidth * 2;
+ int minimumSize = ((element->flags & UI_BUTTON_SMALL) ? 0
+ : isMenuItem ? UI_SIZE_MENU_ITEM_MINIMUM_WIDTH
+ : UI_SIZE_BUTTON_MINIMUM_WIDTH)
+ * element->window->scale;
+ return paddedSize > minimumSize ? paddedSize : minimumSize;
+ } else if (message == UI_MSG_PAINT) {
+ UIPainter *painter = (UIPainter *) dp;
+
+ uint32_t color, textColor;
+ _UIButtonCalculateColors(element, &color, &textColor);
+
+ UIDrawRectangle(painter, element->bounds, color, ui.theme.border, UI_RECT_1(isMenuItem ? 0 : 1));
+
+ if (element->flags & UI_BUTTON_CHECKED) {
+ UIDrawBlock(painter, UIRectangleAdd(element->bounds,
+ UI_RECT_1I((int) (UI_SIZE_BUTTON_CHECKED_AREA * element->window->scale))), ui.theme.buttonPressed);
+ }
+
+ UIRectangle bounds = UIRectangleAdd(element->bounds, UI_RECT_2I((int) (UI_SIZE_MENU_ITEM_MARGIN * element->window->scale), 0));
+
+ if (isMenuItem) {
+ if (button->labelBytes == -1) {
+ button->labelBytes = _UIStringLength(button->label);
+ }
+
+ int tab = 0;
+ for (; tab < button->labelBytes && button->label[tab] != '\t'; tab++);
+
+ UIDrawString(painter, bounds, button->label, tab, textColor, UI_ALIGN_LEFT, NULL);
+
+ if (button->labelBytes > tab) {
+ UIDrawString(painter, bounds, button->label + tab + 1, button->labelBytes - tab - 1, textColor, UI_ALIGN_RIGHT, NULL);
+ }
+ } else if (isDropDown) {
+ UIDrawString(painter, bounds, button->label, button->labelBytes, textColor, UI_ALIGN_LEFT, NULL);
+ UIDrawString(painter, bounds, "\x19", 1, textColor, UI_ALIGN_RIGHT, NULL);
+ } else {
+ UIDrawString(painter, element->bounds, button->label, button->labelBytes, textColor, UI_ALIGN_CENTER, NULL);
+ }
+ } else if (message == UI_MSG_UPDATE) {
+ UIElementRepaint(element, NULL);
+ } else if (message == UI_MSG_DESTROY) {
+ UI_FREE(button->label);
+ } else if (message == UI_MSG_LEFT_DOWN) {
+ if (element->flags & UI_BUTTON_CAN_FOCUS) {
+ UIElementFocus(element);
+ }
+ } else if (message == UI_MSG_KEY_TYPED) {
+ UIKeyTyped *m = (UIKeyTyped *) dp;
+
+ if (m->textBytes == 1 && m->text[0] == ' ') {
+ UIElementMessage(element, UI_MSG_CLICKED, 0, 0);
+ UIElementRepaint(element, NULL);
+ }
+ } else if (message == UI_MSG_CLICKED) {
+ if (button->invoke) {
+ button->invoke(element->cp);
+ }
+ }
+
+ return 0;
+}
+
+UIButton *UIButtonCreate(UIElement *parent, uint32_t flags, const char *label, ptrdiff_t labelBytes) {
+ UIButton *button = (UIButton *) UIElementCreate(sizeof(UIButton), parent, flags | UI_ELEMENT_TAB_STOP, _UIButtonMessage, "Button");
+ button->label = UIStringCopy(label, (button->labelBytes = labelBytes));
+ return button;
+}
+
+int _UICheckboxMessage(UIElement *element, UIMessage message, int di, void *dp) {
+ UICheckbox *box = (UICheckbox *) element;
+
+ if (message == UI_MSG_GET_HEIGHT) {
+ return UI_SIZE_BUTTON_HEIGHT * element->window->scale;
+ } else if (message == UI_MSG_GET_WIDTH) {
+ int labelSize = UIMeasureStringWidth(box->label, box->labelBytes);
+ return (labelSize + UI_SIZE_CHECKBOX_BOX + UI_SIZE_CHECKBOX_GAP) * element->window->scale;
+ } else if (message == UI_MSG_PAINT) {
+ UIPainter *painter = (UIPainter *) dp;
+ uint32_t color, textColor;
+ _UIButtonCalculateColors(element, &color, &textColor);
+ int midY = (element->bounds.t + element->bounds.b) / 2;
+ UIRectangle boxBounds = UI_RECT_4(element->bounds.l, element->bounds.l + UI_SIZE_CHECKBOX_BOX,
+ midY - UI_SIZE_CHECKBOX_BOX / 2, midY + UI_SIZE_CHECKBOX_BOX / 2);
+ UIDrawRectangle(painter, boxBounds, color, ui.theme.border, UI_RECT_1(1));
+ UIDrawString(painter, UIRectangleAdd(boxBounds, UI_RECT_4(1, 0, 0, 0)),
+ box->check == UI_CHECK_CHECKED ? "*" : box->check == UI_CHECK_INDETERMINATE ? "-" : " ", -1,
+ textColor, UI_ALIGN_CENTER, NULL);
+ UIDrawString(painter, UIRectangleAdd(element->bounds, UI_RECT_4(UI_SIZE_CHECKBOX_BOX + UI_SIZE_CHECKBOX_GAP, 0, 0, 0)),
+ box->label, box->labelBytes, textColor, UI_ALIGN_LEFT, NULL);
+ } else if (message == UI_MSG_UPDATE) {
+ UIElementRepaint(element, NULL);
+ } else if (message == UI_MSG_DESTROY) {
+ UI_FREE(box->label);
+ } else if (message == UI_MSG_KEY_TYPED) {
+ UIKeyTyped *m = (UIKeyTyped *) dp;
+
+ if (m->textBytes == 1 && m->text[0] == ' ') {
+ UIElementMessage(element, UI_MSG_CLICKED, 0, 0);
+ UIElementRepaint(element, NULL);
+ }
+ } else if (message == UI_MSG_CLICKED) {
+ box->check = (box->check + 1) % ((element->flags & UI_CHECKBOX_ALLOW_INDETERMINATE) ? 3 : 2);
+ UIElementRepaint(element, NULL);
+ if (box->invoke) box->invoke(element->cp);
+ }
+
+ return 0;
+}
+
+UICheckbox *UICheckboxCreate(UIElement *parent, uint32_t flags, const char *label, ptrdiff_t labelBytes) {
+ UICheckbox *box = (UICheckbox *) UIElementCreate(sizeof(UICheckbox), parent, flags | UI_ELEMENT_TAB_STOP, _UICheckboxMessage, "Checkbox");
+ box->label = UIStringCopy(label, (box->labelBytes = labelBytes));
+ return box;
+}
+
+int _UILabelMessage(UIElement *element, UIMessage message, int di, void *dp) {
+ UILabel *label = (UILabel *) element;
+
+ if (message == UI_MSG_GET_HEIGHT) {
+ return UIMeasureStringHeight();
+ } else if (message == UI_MSG_GET_WIDTH) {
+ return UIMeasureStringWidth(label->label, label->labelBytes);
+ } else if (message == UI_MSG_PAINT) {
+ UIPainter *painter = (UIPainter *) dp;
+ UIDrawString(painter, element->bounds, label->label, label->labelBytes, ui.theme.text, UI_ALIGN_LEFT, NULL);
+ } else if (message == UI_MSG_DESTROY) {
+ UI_FREE(label->label);
+ }
+
+ return 0;
+}
+
+void UILabelSetContent(UILabel *label, const char *string, ptrdiff_t stringBytes) {
+ UI_FREE(label->label);
+ label->label = UIStringCopy(string, (label->labelBytes = stringBytes));
+}
+
+UILabel *UILabelCreate(UIElement *parent, uint32_t flags, const char *string, ptrdiff_t stringBytes) {
+ UILabel *label = (UILabel *) UIElementCreate(sizeof(UILabel), parent, flags, _UILabelMessage, "Label");
+ label->label = UIStringCopy(string, (label->labelBytes = stringBytes));
+ return label;
+}
+
+int _UISplitPaneMessage(UIElement *element, UIMessage message, int di, void *dp);
+
+int _UISplitterMessage(UIElement *element, UIMessage message, int di, void *dp) {
+ UISplitPane *splitPane = (UISplitPane *) element->parent;
+ bool vertical = splitPane->e.flags & UI_SPLIT_PANE_VERTICAL;
+
+ if (message == UI_MSG_PAINT) {
+ UIRectangle borders = vertical ? UI_RECT_2(0, 1) : UI_RECT_2(1, 0);
+ UIDrawRectangle((UIPainter *) dp, element->bounds, ui.theme.buttonNormal, ui.theme.border, borders);
+ } else if (message == UI_MSG_GET_CURSOR) {
+ return vertical ? UI_CURSOR_SPLIT_V : UI_CURSOR_SPLIT_H;
+ } else if (message == UI_MSG_MOUSE_DRAG) {
+ int cursor = vertical ? element->window->cursorY : element->window->cursorX;
+ int splitterSize = UI_SIZE_SPLITTER * element->window->scale;
+ int space = (vertical ? UI_RECT_HEIGHT(splitPane->e.bounds) : UI_RECT_WIDTH(splitPane->e.bounds)) - splitterSize;
+ float oldWeight = splitPane->weight;
+ splitPane->weight = (float) (cursor - splitterSize / 2 - (vertical ? splitPane->e.bounds.t : splitPane->e.bounds.l)) / space;
+ if (splitPane->weight < 0.05f) splitPane->weight = 0.05f;
+ if (splitPane->weight > 0.95f) splitPane->weight = 0.95f;
+
+ if (element->next->next->messageClass == _UISplitPaneMessage
+ && (element->next->next->flags & UI_SPLIT_PANE_VERTICAL) == (splitPane->e.flags & UI_SPLIT_PANE_VERTICAL)) {
+ UISplitPane *subSplitPane = (UISplitPane *) element->next->next;
+ subSplitPane->weight = (splitPane->weight - oldWeight - subSplitPane->weight + oldWeight * subSplitPane->weight) / (-1 + splitPane->weight);
+ if (subSplitPane->weight < 0.05f) subSplitPane->weight = 0.05f;
+ if (subSplitPane->weight > 0.95f) subSplitPane->weight = 0.95f;
+ }
+
+ UIElementRefresh(&splitPane->e);
+ }
+
+ return 0;
+}
+
+int _UISplitPaneMessage(UIElement *element, UIMessage message, int di, void *dp) {
+ UISplitPane *splitPane = (UISplitPane *) element;
+ bool vertical = splitPane->e.flags & UI_SPLIT_PANE_VERTICAL;
+
+ if (message == UI_MSG_LAYOUT) {
+ UIElement *splitter = element->children;
+ UI_ASSERT(splitter);
+ UIElement *left = splitter->next;
+ UI_ASSERT(left);
+ UIElement *right = left->next;
+ UI_ASSERT(right);
+ UI_ASSERT(!right->next);
+
+ int splitterSize = UI_SIZE_SPLITTER * element->window->scale;
+ int space = (vertical ? UI_RECT_HEIGHT(element->bounds) : UI_RECT_WIDTH(element->bounds)) - splitterSize;
+ int leftSize = space * splitPane->weight;
+ int rightSize = space - leftSize;
+
+ if (vertical) {
+ UIElementMove(left, UI_RECT_4(element->bounds.l, element->bounds.r, element->bounds.t, element->bounds.t + leftSize), false);
+ UIElementMove(splitter, UI_RECT_4(element->bounds.l, element->bounds.r, element->bounds.t + leftSize, element->bounds.t + leftSize + splitterSize), false);
+ UIElementMove(right, UI_RECT_4(element->bounds.l, element->bounds.r, element->bounds.b - rightSize, element->bounds.b), false);
+ } else {
+ UIElementMove(left, UI_RECT_4(element->bounds.l, element->bounds.l + leftSize, element->bounds.t, element->bounds.b), false);
+ UIElementMove(splitter, UI_RECT_4(element->bounds.l + leftSize, element->bounds.l + leftSize + splitterSize, element->bounds.t, element->bounds.b), false);
+ UIElementMove(right, UI_RECT_4(element->bounds.r - rightSize, element->bounds.r, element->bounds.t, element->bounds.b), false);
+ }
+ }
+
+ return 0;
+}
+
+UISplitPane *UISplitPaneCreate(UIElement *parent, uint32_t flags, float weight) {
+ UISplitPane *splitPane = (UISplitPane *) UIElementCreate(sizeof(UISplitPane), parent, flags, _UISplitPaneMessage, "Split Pane");
+ splitPane->weight = weight;
+ UIElementCreate(sizeof(UIElement), &splitPane->e, 0, _UISplitterMessage, "Splitter");
+ return splitPane;
+}
+
+int _UITabPaneMessage(UIElement *element, UIMessage message, int di, void *dp) {
+ UITabPane *tabPane = (UITabPane *) element;
+
+ if (message == UI_MSG_PAINT) {
+ UIPainter *painter = (UIPainter *) dp;
+ UIRectangle top = element->bounds;
+ top.b = top.t + UI_SIZE_BUTTON_HEIGHT * element->window->scale;
+ UIDrawRectangle(painter, top, ui.theme.panel1, ui.theme.border, UI_RECT_4(0, 0, 0, 1));
+
+ UIRectangle tab = top;
+ tab.l += UI_SIZE_TAB_PANE_SPACE_LEFT * element->window->scale;
+ tab.t += UI_SIZE_TAB_PANE_SPACE_TOP * element->window->scale;
+
+ int position = 0;
+ int index = 0;
+
+ while (true) {
+ int end = position;
+ for (; tabPane->tabs[end] != '\t' && tabPane->tabs[end]; end++);
+
+ int width = UIMeasureStringWidth(tabPane->tabs, end - position);
+ tab.r = tab.l + width + UI_SIZE_BUTTON_PADDING;
+
+ uint32_t color = tabPane->active == index ? ui.theme.buttonPressed : ui.theme.buttonNormal;
+
+ UIRectangle t = tab;
+
+ if (tabPane->active == index) {
+ t.b++;
+ t.t--;
+ } else {
+ t.t++;
+ }
+
+ UIDrawRectangle(painter, t, color, ui.theme.border, UI_RECT_1(1));
+ UIDrawString(painter, tab, tabPane->tabs + position, end - position, ui.theme.text, UI_ALIGN_CENTER, NULL);
+ tab.l = tab.r - 1;
+
+ if (tabPane->tabs[end] == '\t') {
+ position = end + 1;
+ index++;
+ } else {
+ break;
+ }
+ }
+ } else if (message == UI_MSG_LEFT_DOWN) {
+ UIRectangle tab = element->bounds;
+ tab.b = tab.t + UI_SIZE_BUTTON_HEIGHT * element->window->scale;
+ tab.l += UI_SIZE_TAB_PANE_SPACE_LEFT * element->window->scale;
+ tab.t += UI_SIZE_TAB_PANE_SPACE_TOP * element->window->scale;
+
+ int position = 0;
+ int index = 0;
+
+ while (true) {
+ int end = position;
+ for (; tabPane->tabs[end] != '\t' && tabPane->tabs[end]; end++);
+
+ int width = UIMeasureStringWidth(tabPane->tabs, end - position);
+ tab.r = tab.l + width + UI_SIZE_BUTTON_PADDING;
+
+ if (UIRectangleContains(tab, element->window->cursorX, element->window->cursorY)) {
+ tabPane->active = index;
+ UIElementMessage(element, UI_MSG_LAYOUT, 0, 0);
+ UIElementRepaint(element, NULL);
+ break;
+ }
+
+ tab.l = tab.r - 1;
+
+ if (tabPane->tabs[end] == '\t') {
+ position = end + 1;
+ index++;
+ } else {
+ break;
+ }
+ }
+ } else if (message == UI_MSG_LAYOUT) {
+ UIElement *child = element->children;
+ int index = 0;
+
+ UIRectangle content = element->bounds;
+ content.t += UI_SIZE_BUTTON_HEIGHT * element->window->scale;
+
+ while (child) {
+ if (tabPane->active == index) {
+ child->flags &= ~UI_ELEMENT_HIDE;
+ UIElementMove(child, content, false);
+ UIElementMessage(child, UI_MSG_TAB_SELECTED, 0, 0);
+ } else {
+ child->flags |= UI_ELEMENT_HIDE;
+ }
+
+ child = child->next;
+ index++;
+ }
+ } else if (message == UI_MSG_GET_HEIGHT) {
+ UIElement *child = element->children;
+ int index = 0;
+ int baseHeight = UI_SIZE_BUTTON_HEIGHT * element->window->scale;
+
+ while (child) {
+ if (tabPane->active == index) {
+ return baseHeight + UIElementMessage(child, UI_MSG_GET_HEIGHT, di, dp);
+ }
+
+ child = child->next;
+ index++;
+ }
+ } else if (message == UI_MSG_DESTROY) {
+ UI_FREE(tabPane->tabs);
+ }
+
+ return 0;
+}
+
+UITabPane *UITabPaneCreate(UIElement *parent, uint32_t flags, const char *tabs) {
+ UITabPane *tabPane = (UITabPane *) UIElementCreate(sizeof(UITabPane), parent, flags, _UITabPaneMessage, "Tab Pane");
+ tabPane->tabs = UIStringCopy(tabs, -1);
+ return tabPane;
+}
+
+int _UISpacerMessage(UIElement *element, UIMessage message, int di, void *dp) {
+ UISpacer *spacer = (UISpacer *) element;
+
+ if (message == UI_MSG_GET_HEIGHT) {
+ return spacer->height * element->window->scale;
+ } else if (message == UI_MSG_GET_WIDTH) {
+ return spacer->width * element->window->scale;
+ } else if (message == UI_MSG_PAINT && (element->flags & UI_SPACER_LINE)) {
+ UIDrawBlock((UIPainter *) dp, element->bounds, ui.theme.border);
+ }
+
+ return 0;
+}
+
+UISpacer *UISpacerCreate(UIElement *parent, uint32_t flags, int width, int height) {
+ UISpacer *spacer = (UISpacer *) UIElementCreate(sizeof(UISpacer), parent, flags, _UISpacerMessage, "Spacer");
+ spacer->width = width;
+ spacer->height = height;
+ return spacer;
+}
+
+int _UIScrollBarMessage(UIElement *element, UIMessage message, int di, void *dp) {
+ UIScrollBar *scrollBar = (UIScrollBar *) element;
+
+ if (message == UI_MSG_GET_WIDTH || message == UI_MSG_GET_HEIGHT) {
+ return UI_SIZE_SCROLL_BAR * element->window->scale;
+ } else if (message == UI_MSG_LAYOUT) {
+ UIElement *up = element->children;
+ UIElement *thumb = up->next;
+ UIElement *down = thumb->next;
+
+ if (scrollBar->page >= scrollBar->maximum || scrollBar->maximum <= 0 || scrollBar->page <= 0) {
+ up->flags |= UI_ELEMENT_HIDE;
+ thumb->flags |= UI_ELEMENT_HIDE;
+ down->flags |= UI_ELEMENT_HIDE;
+
+ scrollBar->position = 0;
+ } else {
+ up->flags &= ~UI_ELEMENT_HIDE;
+ thumb->flags &= ~UI_ELEMENT_HIDE;
+ down->flags &= ~UI_ELEMENT_HIDE;
+
+ int size = scrollBar->horizontal ? UI_RECT_WIDTH(element->bounds) : UI_RECT_HEIGHT(element->bounds);
+ int thumbSize = size * scrollBar->page / scrollBar->maximum;
+
+ if (thumbSize < UI_SIZE_SCROLL_MINIMUM_THUMB * element->window->scale) {
+ thumbSize = UI_SIZE_SCROLL_MINIMUM_THUMB * element->window->scale;
+ }
+
+ if (scrollBar->position < 0) {
+ scrollBar->position = 0;
+ } else if (scrollBar->position > scrollBar->maximum - scrollBar->page) {
+ scrollBar->position = scrollBar->maximum - scrollBar->page;
+ }
+
+ int thumbPosition = scrollBar->position / (scrollBar->maximum - scrollBar->page) * (size - thumbSize);
+
+ if (scrollBar->position == scrollBar->maximum - scrollBar->page) {
+ thumbPosition = size - thumbSize;
+ }
+
+ if (scrollBar->horizontal) {
+ UIRectangle r = element->bounds;
+ r.r = r.l + thumbPosition;
+ UIElementMove(up, r, false);
+ r.l = r.r, r.r = r.l + thumbSize;
+ UIElementMove(thumb, r, false);
+ r.l = r.r, r.r = element->bounds.r;
+ UIElementMove(down, r, false);
+ } else {
+ UIRectangle r = element->bounds;
+ r.b = r.t + thumbPosition;
+ UIElementMove(up, r, false);
+ r.t = r.b, r.b = r.t + thumbSize;
+ UIElementMove(thumb, r, false);
+ r.t = r.b, r.b = element->bounds.b;
+ UIElementMove(down, r, false);
+ }
+ }
+ } else if (message == UI_MSG_PAINT) {
+ if (scrollBar->page >= scrollBar->maximum || scrollBar->maximum <= 0 || scrollBar->page <= 0) {
+ UIDrawBlock((UIPainter *) dp, element->bounds, ui.theme.panel1);
+ }
+ } else if (message == UI_MSG_MOUSE_WHEEL) {
+ scrollBar->position += di;
+ UIElementRefresh(element);
+ UIElementMessage(element->parent, UI_MSG_SCROLLED, 0, 0);
+ return 1;
+ }
+
+ return 0;
+}
+
+int _UIScrollUpDownMessage(UIElement *element, UIMessage message, int di, void *dp) {
+ UIScrollBar *scrollBar = (UIScrollBar *) element->parent;
+ bool isDown = element->cp;
+
+ if (message == UI_MSG_PAINT) {
+ UIPainter *painter = (UIPainter *) dp;
+ uint32_t color = element == element->window->pressed ? ui.theme.buttonPressed
+ : element == element->window->hovered ? ui.theme.buttonHovered : ui.theme.panel2;
+ UIDrawRectangle(painter, element->bounds, color, ui.theme.border, UI_RECT_1(0));
+
+ if (scrollBar->horizontal) {
+ UIDrawGlyph(painter, isDown ? (element->bounds.r - ui.activeFont->glyphWidth - 2 * element->window->scale)
+ : (element->bounds.l + 2 * element->window->scale),
+ (element->bounds.t + element->bounds.b - ui.activeFont->glyphHeight) / 2,
+ isDown ? 26 : 27, ui.theme.text);
+ } else {
+ UIDrawGlyph(painter, (element->bounds.l + element->bounds.r - ui.activeFont->glyphWidth) / 2 + 1,
+ isDown ? (element->bounds.b - ui.activeFont->glyphHeight - 2 * element->window->scale)
+ : (element->bounds.t + 2 * element->window->scale),
+ isDown ? 25 : 24, ui.theme.text);
+ }
+ } else if (message == UI_MSG_UPDATE) {
+ UIElementRepaint(element, NULL);
+ } else if (message == UI_MSG_LEFT_DOWN) {
+ UIElementAnimate(element, false);
+ scrollBar->lastAnimateTime = UI_CLOCK();
+ } else if (message == UI_MSG_LEFT_UP) {
+ UIElementAnimate(element, true);
+ } else if (message == UI_MSG_ANIMATE) {
+ UI_CLOCK_T previous = scrollBar->lastAnimateTime;
+ UI_CLOCK_T current = UI_CLOCK();
+ UI_CLOCK_T delta = current - previous;
+ double deltaSeconds = (double) delta / UI_CLOCKS_PER_SECOND;
+ if (deltaSeconds > 0.1) deltaSeconds = 0.1;
+ double deltaPixels = deltaSeconds * scrollBar->page * 3;
+ scrollBar->lastAnimateTime = current;
+ if (isDown) scrollBar->position += deltaPixels;
+ else scrollBar->position -= deltaPixels;
+ UIElementRefresh(&scrollBar->e);
+ UIElementMessage(scrollBar->e.parent, UI_MSG_SCROLLED, 0, 0);
+ }
+
+ return 0;
+}
+
+int _UIScrollThumbMessage(UIElement *element, UIMessage message, int di, void *dp) {
+ UIScrollBar *scrollBar = (UIScrollBar *) element->parent;
+
+ if (message == UI_MSG_PAINT) {
+ UIPainter *painter = (UIPainter *) dp;
+ uint32_t color = element == element->window->pressed ? ui.theme.buttonPressed
+ : element == element->window->hovered ? ui.theme.buttonHovered : ui.theme.buttonNormal;
+ UIDrawRectangle(painter, element->bounds, color, ui.theme.border, UI_RECT_1(2));
+ } else if (message == UI_MSG_UPDATE) {
+ UIElementRepaint(element, NULL);
+ } else if (message == UI_MSG_MOUSE_DRAG && element->window->pressedButton == 1) {
+ if (!scrollBar->inDrag) {
+ scrollBar->inDrag = true;
+
+ if (scrollBar->horizontal) {
+ scrollBar->dragOffset = element->bounds.l - scrollBar->e.bounds.l - element->window->cursorX;
+ } else {
+ scrollBar->dragOffset = element->bounds.t - scrollBar->e.bounds.t - element->window->cursorY;
+ }
+ }
+
+ int thumbPosition = (scrollBar->horizontal ? element->window->cursorX : element->window->cursorY) + scrollBar->dragOffset;
+ int size = scrollBar->horizontal ? (UI_RECT_WIDTH(scrollBar->e.bounds) - UI_RECT_WIDTH(element->bounds))
+ : (UI_RECT_HEIGHT(scrollBar->e.bounds) - UI_RECT_HEIGHT(element->bounds));
+ scrollBar->position = (double) thumbPosition / size * (scrollBar->maximum - scrollBar->page);
+ UIElementRefresh(&scrollBar->e);
+ UIElementMessage(scrollBar->e.parent, UI_MSG_SCROLLED, 0, 0);
+ } else if (message == UI_MSG_LEFT_UP) {
+ scrollBar->inDrag = false;
+ }
+
+ return 0;
+}
+
+UIScrollBar *UIScrollBarCreate(UIElement *parent, uint32_t flags) {
+ UIScrollBar *scrollBar = (UIScrollBar *) UIElementCreate(sizeof(UIScrollBar), parent, flags, _UIScrollBarMessage, "Scroll Bar");
+ bool horizontal = scrollBar->horizontal = flags & UI_SCROLL_BAR_HORIZONTAL;
+ UIElementCreate(sizeof(UIElement), &scrollBar->e, flags, _UIScrollUpDownMessage, !horizontal ? "Scroll Up" : "Scroll Left")->cp = (void *) (uintptr_t) 0;
+ UIElementCreate(sizeof(UIElement), &scrollBar->e, flags, _UIScrollThumbMessage, "Scroll Thumb");
+ UIElementCreate(sizeof(UIElement), &scrollBar->e, flags, _UIScrollUpDownMessage, !horizontal ? "Scroll Down" : "Scroll Right")->cp = (void *) (uintptr_t) 1;
+ return scrollBar;
+}
+
+bool _UICharIsAlpha(char c) {
+ return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
+}
+
+bool _UICharIsDigit(char c) {
+ return c >= '0' && c <= '9';
+}
+
+bool _UICharIsAlphaOrDigitOrUnderscore(char c) {
+ return _UICharIsAlpha(c) || _UICharIsDigit(c) || c == '_';
+}
+
+int UICodeHitTest(UICode *code, int x, int y) {
+ x -= code->e.bounds.l;
+
+ if (x < 0 || x >= UI_RECT_WIDTH(code->e.bounds) - UI_SIZE_SCROLL_BAR * code->e.window->scale) {
+ return 0;
+ }
+
+ y -= code->e.bounds.t - code->vScroll->position;
+
+ UIFont *previousFont = UIFontActivate(code->font);
+ int lineHeight = UIMeasureStringHeight();
+ bool inMargin = x < UI_SIZE_CODE_MARGIN + UI_SIZE_CODE_MARGIN_GAP / 2 && (~code->e.flags & UI_CODE_NO_MARGIN);
+ UIFontActivate(previousFont);
+
+ if (y < 0 || y >= lineHeight * code->lineCount) {
+ return 0;
+ }
+
+ int line = y / lineHeight + 1;
+ return inMargin ? -line : line;
+}
+
+int UIDrawStringHighlighted(UIPainter *painter, UIRectangle lineBounds, const char *string, ptrdiff_t bytes, int tabSize) {
+ if (bytes == -1) bytes = _UIStringLength(string);
+ if (bytes > 10000) bytes = 10000;
+
+ uint32_t colors[] = {
+ ui.theme.codeDefault,
+ ui.theme.codeComment,
+ ui.theme.codeString,
+ ui.theme.codeNumber,
+ ui.theme.codeOperator,
+ ui.theme.codePreprocessor,
+ };
+
+ int x = lineBounds.l;
+ int y = (lineBounds.t + lineBounds.b - UIMeasureStringHeight()) / 2;
+ int ti = 0;
+ int lexState = 0;
+ bool inComment = false, inIdentifier = false, inChar = false, startedString = false;
+ uint32_t last = 0;
+
+ while (bytes--) {
+ char c = *string++;
+
+ last <<= 8;
+ last |= c;
+
+ if (lexState == 4) {
+ lexState = 0;
+ } else if (lexState == 1) {
+ if ((last & 0xFF0000) == ('*' << 16) && (last & 0xFF00) == ('/' << 8) && inComment) {
+ lexState = 0, inComment = false;
+ }
+ } else if (lexState == 3) {
+ if (!_UICharIsAlpha(c) && !_UICharIsDigit(c)) {
+ lexState = 0;
+ }
+ } else if (lexState == 2) {
+ if (!startedString) {
+ if (!inChar && ((last >> 8) & 0xFF) == '"' && ((last >> 16) & 0xFF) != '\\') {
+ lexState = 0;
+ } else if (inChar && ((last >> 8) & 0xFF) == '\'' && ((last >> 16) & 0xFF) != '\\') {
+ lexState = 0;
+ }
+ }
+
+ startedString = false;
+ }
+
+ if (lexState == 0) {
+ if (c == '#') {
+ lexState = 5;
+ } else if (c == '/' && *string == '/') {
+ lexState = 1;
+ } else if (c == '/' && *string == '*') {
+ lexState = 1, inComment = true;
+ } else if (c == '"') {
+ lexState = 2;
+ inChar = false;
+ startedString = true;
+ } else if (c == '\'') {
+ lexState = 2;
+ inChar = true;
+ startedString = true;
+ } else if (_UICharIsDigit(c) && !inIdentifier) {
+ lexState = 3;
+ } else if (!_UICharIsAlpha(c) && !_UICharIsDigit(c)) {
+ lexState = 4;
+ inIdentifier = false;
+ } else {
+ inIdentifier = true;
+ }
+ }
+
+ if (c == '\t') {
+ x += ui.activeFont->glyphWidth, ti++;
+ while (ti % tabSize) x += ui.activeFont->glyphWidth, ti++;
+ } else {
+ UIDrawGlyph(painter, x, y, c, colors[lexState]);
+ x += ui.activeFont->glyphWidth, ti++;
+ }
+ }
+
+ return x;
+}
+
+int _UICodeMessage(UIElement *element, UIMessage message, int di, void *dp) {
+ UICode *code = (UICode *) element;
+
+ if (message == UI_MSG_LAYOUT) {
+ UIFont *previousFont = UIFontActivate(code->font);
+
+ if (code->moveScrollToFocusNextLayout) {
+ code->vScroll->position = (code->focused + 0.5) * UIMeasureStringHeight() - UI_RECT_HEIGHT(code->e.bounds) / 2;
+ }
+
+ UIRectangle scrollBarBounds = element->bounds;
+ scrollBarBounds.l = scrollBarBounds.r - UI_SIZE_SCROLL_BAR * code->e.window->scale;
+ code->vScroll->maximum = code->lineCount * UIMeasureStringHeight();
+ code->vScroll->page = UI_RECT_HEIGHT(element->bounds);
+ UIFontActivate(previousFont);
+ UIElementMove(&code->vScroll->e, scrollBarBounds, true);
+ } else if (message == UI_MSG_PAINT) {
+ UIFont *previousFont = UIFontActivate(code->font);
+
+ UIPainter *painter = (UIPainter *) dp;
+ UIRectangle lineBounds = element->bounds;
+ lineBounds.r -= UI_SIZE_SCROLL_BAR * code->e.window->scale;
+
+ if (~code->e.flags & UI_CODE_NO_MARGIN) {
+ lineBounds.l += UI_SIZE_CODE_MARGIN + UI_SIZE_CODE_MARGIN_GAP;
+ }
+
+ int lineHeight = UIMeasureStringHeight();
+ lineBounds.t -= (int64_t) code->vScroll->position % lineHeight;
+
+ UIDrawBlock(painter, element->bounds, ui.theme.codeBackground);
+
+ for (int i = code->vScroll->position / lineHeight; i < code->lineCount; i++) {
+ if (lineBounds.t > element->clip.b) {
+ break;
+ }
+
+ lineBounds.b = lineBounds.t + lineHeight;
+
+ if (~code->e.flags & UI_CODE_NO_MARGIN) {
+ char string[16];
+ int p = 16;
+ int lineNumber = i + 1;
+
+ while (lineNumber) {
+ string[--p] = (lineNumber % 10) + '0';
+ lineNumber /= 10;
+ }
+
+ UIRectangle marginBounds = lineBounds;
+ marginBounds.r = marginBounds.l - UI_SIZE_CODE_MARGIN_GAP;
+ marginBounds.l -= UI_SIZE_CODE_MARGIN + UI_SIZE_CODE_MARGIN_GAP;
+
+ uint32_t marginColor = UIElementMessage(element, UI_MSG_CODE_GET_MARGIN_COLOR, i + 1, 0);
+
+ if (marginColor) {
+ UIDrawBlock(painter, marginBounds, marginColor);
+ }
+
+ UIDrawString(painter, marginBounds, string + p, 16 - p, ui.theme.codeDefault, UI_ALIGN_RIGHT, NULL);
+ }
+
+ if (code->focused == i) {
+ UIDrawBlock(painter, lineBounds, ui.theme.codeFocused);
+ }
+
+ int x = UIDrawStringHighlighted(painter, lineBounds, code->content + code->lines[i].offset, code->lines[i].bytes, code->tabSize);
+ int y = (lineBounds.t + lineBounds.b - UIMeasureStringHeight()) / 2;
+
+ UICodeDecorateLine m = { 0 };
+ m.x = x, m.y = y, m.bounds = lineBounds, m.index = i + 1, m.painter = painter;
+ UIElementMessage(element, UI_MSG_CODE_DECORATE_LINE, 0, &m);
+
+ lineBounds.t += lineHeight;
+ }
+
+ UIFontActivate(previousFont);
+ } else if (message == UI_MSG_SCROLLED) {
+ code->moveScrollToFocusNextLayout = false;
+ UIElementRefresh(element);
+ } else if (message == UI_MSG_MOUSE_WHEEL) {
+ return UIElementMessage(&code->vScroll->e, message, di, dp);
+ } else if (message == UI_MSG_GET_CURSOR) {
+ if (UICodeHitTest(code, element->window->cursorX, element->window->cursorY) < 0) {
+ return UI_CURSOR_FLIPPED_ARROW;
+ }
+ } else if (message == UI_MSG_DESTROY) {
+ UI_FREE(code->content);
+ UI_FREE(code->lines);
+ }
+
+ return 0;
+}
+
+void UICodeFocusLine(UICode *code, int index) {
+ code->focused = index - 1;
+ code->moveScrollToFocusNextLayout = true;
+}
+
+void UICodeInsertContent(UICode *code, const char *content, ptrdiff_t byteCount, bool replace) {
+ UIFont *previousFont = UIFontActivate(code->font);
+
+ if (byteCount == -1) {
+ byteCount = _UIStringLength(content);
+ }
+
+ if (byteCount > 1000000000) {
+ byteCount = 1000000000;
+ }
+
+ if (replace) {
+ UI_FREE(code->content);
+ UI_FREE(code->lines);
+ code->content = NULL;
+ code->lines = NULL;
+ code->contentBytes = 0;
+ code->lineCount = 0;
+ }
+
+ code->content = (char *) UI_REALLOC(code->content, code->contentBytes + byteCount);
+
+ if (!byteCount) {
+ return;
+ }
+
+ int lineCount = content[byteCount - 1] != '\n';
+
+ for (int i = 0; i < byteCount; i++) {
+ code->content[i + code->contentBytes] = content[i];
+
+ if (content[i] == '\n') {
+ lineCount++;
+ }
+ }
+
+ code->lines = (UICodeLine *) UI_REALLOC(code->lines, sizeof(UICodeLine) * (code->lineCount + lineCount));
+ int offset = 0, lineIndex = 0;
+
+ for (intptr_t i = 0; i <= byteCount && lineIndex < lineCount; i++) {
+ if (content[i] == '\n' || i == byteCount) {
+ UICodeLine line = { 0 };
+ line.offset = offset + code->contentBytes;
+ line.bytes = i - offset;
+ code->lines[code->lineCount + lineIndex] = line;
+ lineIndex++;
+ offset = i + 1;
+ }
+ }
+
+ code->lineCount += lineCount;
+ code->contentBytes += byteCount;
+
+ if (!replace) {
+ code->vScroll->position = code->lineCount * UIMeasureStringHeight();
+ }
+
+ UIFontActivate(previousFont);
+}
+
+UICode *UICodeCreate(UIElement *parent, uint32_t flags) {
+ UICode *code = (UICode *) UIElementCreate(sizeof(UICode), parent, flags, _UICodeMessage, "Code");
+ code->font = ui.activeFont;
+ code->vScroll = UIScrollBarCreate(&code->e, 0);
+ code->focused = -1;
+ code->tabSize = 4;
+ return code;
+}
+
+int _UIGaugeMessage(UIElement *element, UIMessage message, int di, void *dp) {
+ UIGauge *gauge = (UIGauge *) element;
+
+ if (message == UI_MSG_GET_HEIGHT) {
+ return UI_SIZE_GAUGE_HEIGHT * element->window->scale;
+ } else if (message == UI_MSG_GET_WIDTH) {
+ return UI_SIZE_GAUGE_WIDTH * element->window->scale;
+ } else if (message == UI_MSG_PAINT) {
+ UIPainter *painter = (UIPainter *) dp;
+ UIDrawRectangle(painter, element->bounds, ui.theme.buttonNormal, ui.theme.border, UI_RECT_1(1));
+ UIRectangle filled = UIRectangleAdd(element->bounds, UI_RECT_1I(1));
+ filled.r = filled.l + UI_RECT_WIDTH(filled) * gauge->position;
+ UIDrawBlock(painter, filled, ui.theme.selected);
+ }
+
+ return 0;
+}
+
+UIGauge *UIGaugeCreate(UIElement *parent, uint32_t flags) {
+ return (UIGauge *) UIElementCreate(sizeof(UIGauge), parent, flags, _UIGaugeMessage, "Gauge");
+}
+
+int _UISliderMessage(UIElement *element, UIMessage message, int di, void *dp) {
+ UISlider *slider = (UISlider *) element;
+
+ if (message == UI_MSG_GET_HEIGHT) {
+ return UI_SIZE_SLIDER_HEIGHT * element->window->scale;
+ } else if (message == UI_MSG_GET_WIDTH) {
+ return UI_SIZE_SLIDER_WIDTH * element->window->scale;
+ } else if (message == UI_MSG_PAINT) {
+ UIPainter *painter = (UIPainter *) dp;
+ UIRectangle bounds = element->bounds;
+ int centerY = (bounds.t + bounds.b) / 2;
+ int trackSize = UI_SIZE_SLIDER_TRACK * element->window->scale;
+ int thumbSize = UI_SIZE_SLIDER_THUMB * element->window->scale;
+ int thumbPosition = (UI_RECT_WIDTH(bounds) - thumbSize) * slider->position;
+ UIRectangle track = UI_RECT_4(bounds.l, bounds.r, centerY - (trackSize + 1) / 2, centerY + trackSize / 2);
+ UIDrawRectangle(painter, track, ui.theme.buttonNormal, ui.theme.border, UI_RECT_1(1));
+ bool pressed = element == element->window->pressed;
+ bool hovered = element == element->window->hovered;
+ bool disabled = element->flags & UI_ELEMENT_DISABLED;
+ uint32_t color = disabled ? ui.theme.buttonDisabled : pressed ? ui.theme.buttonPressed : hovered ? ui.theme.buttonHovered : ui.theme.buttonNormal;
+ UIRectangle thumb = UI_RECT_4(bounds.l + thumbPosition, bounds.l + thumbPosition + thumbSize, centerY - (thumbSize + 1) / 2, centerY + thumbSize / 2);
+ UIDrawRectangle(painter, thumb, color, ui.theme.border, UI_RECT_1(1));
+ } else if (message == UI_MSG_LEFT_DOWN || (message == UI_MSG_MOUSE_DRAG && element->window->pressedButton == 1)) {
+ UIRectangle bounds = element->bounds;
+ int thumbSize = UI_SIZE_SLIDER_THUMB * element->window->scale;
+ slider->position = (float) (element->window->cursorX - thumbSize / 2 - bounds.l) / (UI_RECT_WIDTH(bounds) - thumbSize);
+ if (slider->steps > 1) slider->position = (int) (slider->position * (slider->steps - 1) + 0.5f) / (float) (slider->steps - 1);
+ if (slider->position < 0) slider->position = 0;
+ if (slider->position > 1) slider->position = 1;
+ UIElementMessage(element, UI_MSG_VALUE_CHANGED, 0, 0);
+ UIElementRepaint(element, NULL);
+ } else if (message == UI_MSG_UPDATE) {
+ UIElementRepaint(element, NULL);
+ }
+
+ return 0;
+}
+
+UISlider *UISliderCreate(UIElement *parent, uint32_t flags) {
+ return (UISlider *) UIElementCreate(sizeof(UISlider), parent, flags, _UISliderMessage, "Slider");
+}
+
+int UITableHitTest(UITable *table, int x, int y) {
+ x -= table->e.bounds.l;
+
+ if (x < 0 || x >= UI_RECT_WIDTH(table->e.bounds) - UI_SIZE_SCROLL_BAR * table->e.window->scale) {
+ return -1;
+ }
+
+ y -= (table->e.bounds.t + UI_SIZE_TABLE_HEADER * table->e.window->scale) - table->vScroll->position;
+
+ int rowHeight = UI_SIZE_TABLE_ROW * table->e.window->scale;
+
+ if (y < 0 || y >= rowHeight * table->itemCount) {
+ return -1;
+ }
+
+ return y / rowHeight;
+}
+
+int UITableHeaderHitTest(UITable *table, int x, int y) {
+ if (!table->columnCount) return -1;
+ UIRectangle header = table->e.bounds;
+ header.b = header.t + UI_SIZE_TABLE_HEADER * table->e.window->scale;
+ header.l += UI_SIZE_TABLE_COLUMN_GAP * table->e.window->scale;
+ int position = 0, index = 0;
+
+ while (true) {
+ int end = position;
+ for (; table->columns[end] != '\t' && table->columns[end]; end++);
+ header.r = header.l + table->columnWidths[index];
+ if (UIRectangleContains(header, x, y)) return index;
+ header.l += table->columnWidths[index] + UI_SIZE_TABLE_COLUMN_GAP * table->e.window->scale;
+ if (table->columns[end] != '\t') break;
+ position = end + 1, index++;
+ }
+
+ return -1;
+}
+
+bool UITableEnsureVisible(UITable *table, int index) {
+ int rowHeight = UI_SIZE_TABLE_ROW * table->e.window->scale;
+ int y = index * rowHeight;
+ y -= table->vScroll->position;
+ int height = UI_RECT_HEIGHT(table->e.bounds) - UI_SIZE_TABLE_HEADER * table->e.window->scale - rowHeight;
+
+ if (y < 0) {
+ table->vScroll->position += y;
+ UIElementRefresh(&table->e);
+ return true;
+ } else if (y > height) {
+ table->vScroll->position -= height - y;
+ UIElementRefresh(&table->e);
+ return true;
+ } else {
+ return false;
+ }
+}
+
+void UITableResizeColumns(UITable *table) {
+ int position = 0;
+ int count = 0;
+
+ while (true) {
+ int end = position;
+ for (; table->columns[end] != '\t' && table->columns[end]; end++);
+ count++;
+ if (table->columns[end] == '\t') position = end + 1;
+ else break;
+ }
+
+ UI_FREE(table->columnWidths);
+ table->columnWidths = (int *) UI_MALLOC(count * sizeof(int));
+ table->columnCount = count;
+
+ position = 0;
+
+ char buffer[256];
+ UITableGetItem m = { 0 };
+ m.buffer = buffer;
+ m.bufferBytes = sizeof(buffer);
+
+ while (true) {
+ int end = position;
+ for (; table->columns[end] != '\t' && table->columns[end]; end++);
+
+ int longest = UIMeasureStringWidth(table->columns + position, end - position);
+
+ for (int i = 0; i < table->itemCount; i++) {
+ m.index = i;
+ int bytes = UIElementMessage(&table->e, UI_MSG_TABLE_GET_ITEM, 0, &m);
+ int width = UIMeasureStringWidth(buffer, bytes);
+
+ if (width > longest) {
+ longest = width;
+ }
+ }
+
+ table->columnWidths[m.column] = longest;
+ m.column++;
+ if (table->columns[end] == '\t') position = end + 1;
+ else break;
+ }
+}
+
+int _UITableMessage(UIElement *element, UIMessage message, int di, void *dp) {
+ UITable *table = (UITable *) element;
+
+ if (message == UI_MSG_PAINT) {
+ UIPainter *painter = (UIPainter *) dp;
+ UIRectangle bounds = element->bounds;
+ bounds.r -= UI_SIZE_SCROLL_BAR * element->window->scale;
+ UIDrawBlock(painter, bounds, ui.theme.panel2);
+ char buffer[256];
+ UIRectangle row = bounds;
+ int rowHeight = UI_SIZE_TABLE_ROW * element->window->scale;
+ UITableGetItem m = { 0 };
+ m.buffer = buffer;
+ m.bufferBytes = sizeof(buffer);
+ row.t += UI_SIZE_TABLE_HEADER * table->e.window->scale;
+ row.t -= (int64_t) table->vScroll->position % rowHeight;
+ int hovered = UITableHitTest(table, element->window->cursorX, element->window->cursorY);
+
+ for (int i = table->vScroll->position / rowHeight; i < table->itemCount; i++) {
+ if (row.t > element->clip.b) {
+ break;
+ }
+
+ row.b = row.t + rowHeight;
+ m.index = i;
+ m.isSelected = false;
+ m.column = 0;
+ int bytes = UIElementMessage(element, UI_MSG_TABLE_GET_ITEM, 0, &m);
+ uint32_t textColor = ui.theme.text;
+
+ if (m.isSelected) {
+ UIDrawBlock(painter, row, ui.theme.selected);
+ textColor = ui.theme.textSelected;
+ } else if (hovered == i) {
+ UIDrawBlock(painter, row, ui.theme.buttonHovered);
+ }
+
+ UIRectangle cell = row;
+ cell.l += UI_SIZE_TABLE_COLUMN_GAP * table->e.window->scale;
+
+ for (int j = 0; j < table->columnCount; j++) {
+ if (j) {
+ m.column = j;
+ bytes = UIElementMessage(element, UI_MSG_TABLE_GET_ITEM, 0, &m);
+ }
+
+ cell.r = cell.l + table->columnWidths[j];
+ if ((size_t) bytes > m.bufferBytes && bytes > 0) bytes = m.bufferBytes;
+ UIDrawString(painter, cell, buffer, bytes, textColor, UI_ALIGN_LEFT, NULL);
+ cell.l += table->columnWidths[j] + UI_SIZE_TABLE_COLUMN_GAP * table->e.window->scale;
+ }
+
+ row.t += rowHeight;
+ }
+
+ UIRectangle header = bounds;
+ header.b = header.t + UI_SIZE_TABLE_HEADER * table->e.window->scale;
+ UIDrawRectangle(painter, header, ui.theme.panel1, ui.theme.border, UI_RECT_4(0, 0, 0, 1));
+ header.l += UI_SIZE_TABLE_COLUMN_GAP * table->e.window->scale;
+
+ int position = 0;
+ int index = 0;
+
+ if (table->columnCount) {
+ while (true) {
+ int end = position;
+ for (; table->columns[end] != '\t' && table->columns[end]; end++);
+
+ header.r = header.l + table->columnWidths[index];
+ UIDrawString(painter, header, table->columns + position, end - position, ui.theme.text, UI_ALIGN_LEFT, NULL);
+ if (index == table->columnHighlight) UIDrawInvert(painter, header);
+ header.l += table->columnWidths[index] + UI_SIZE_TABLE_COLUMN_GAP * table->e.window->scale;
+
+ if (table->columns[end] == '\t') {
+ position = end + 1;
+ index++;
+ } else {
+ break;
+ }
+ }
+ }
+ } else if (message == UI_MSG_LAYOUT) {
+ UIRectangle scrollBarBounds = element->bounds;
+ scrollBarBounds.l = scrollBarBounds.r - UI_SIZE_SCROLL_BAR * element->window->scale;
+ table->vScroll->maximum = table->itemCount * UI_SIZE_TABLE_ROW * element->window->scale;
+ table->vScroll->page = UI_RECT_HEIGHT(element->bounds) - UI_SIZE_TABLE_HEADER * table->e.window->scale;
+ UIElementMove(&table->vScroll->e, scrollBarBounds, true);
+ } else if (message == UI_MSG_MOUSE_MOVE || message == UI_MSG_UPDATE) {
+ UIElementRepaint(element, NULL);
+ } else if (message == UI_MSG_SCROLLED) {
+ UIElementRefresh(element);
+ } else if (message == UI_MSG_MOUSE_WHEEL) {
+ return UIElementMessage(&table->vScroll->e, message, di, dp);
+ } else if (message == UI_MSG_DESTROY) {
+ UI_FREE(table->columns);
+ UI_FREE(table->columnWidths);
+ }
+
+ return 0;
+}
+
+UITable *UITableCreate(UIElement *parent, uint32_t flags, const char *columns) {
+ UITable *table = (UITable *) UIElementCreate(sizeof(UITable), parent, flags, _UITableMessage, "Table");
+ table->vScroll = UIScrollBarCreate(&table->e, 0);
+ table->columns = UIStringCopy(columns, -1);
+ table->columnHighlight = -1;
+ return table;
+}
+
+void UITextboxReplace(UITextbox *textbox, const char *text, ptrdiff_t bytes, bool sendChangedMessage) {
+ if (bytes == -1) {
+ bytes = _UIStringLength(text);
+ }
+
+ int deleteFrom = textbox->carets[0], deleteTo = textbox->carets[1];
+
+ if (deleteFrom > deleteTo) {
+ UI_SWAP(int, deleteFrom, deleteTo);
+ }
+
+ for (int i = deleteTo; i < textbox->bytes; i++) {
+ textbox->string[i - deleteTo + deleteFrom] = textbox->string[i];
+ }
+
+ textbox->bytes -= deleteTo - deleteFrom;
+ textbox->carets[0] = textbox->carets[1] = deleteFrom;
+
+ textbox->string = (char *) UI_REALLOC(textbox->string, textbox->bytes + bytes);
+
+ for (int i = textbox->bytes + bytes - 1; i >= textbox->carets[0] + bytes; i--) {
+ textbox->string[i] = textbox->string[i - bytes];
+ }
+
+ for (int i = textbox->carets[0]; i < textbox->carets[0] + bytes; i++) {
+ textbox->string[i] = text[i - textbox->carets[0]];
+ }
+
+ textbox->bytes += bytes;
+ textbox->carets[0] += bytes;
+ textbox->carets[1] = textbox->carets[0];
+
+ if (sendChangedMessage) {
+ UIElementMessage(&textbox->e, UI_MSG_VALUE_CHANGED, 0, 0);
+ }
+
+ textbox->e.window->textboxModifiedFlag = true;
+}
+
+void UITextboxClear(UITextbox *textbox, bool sendChangedMessage) {
+ textbox->carets[1] = 0;
+ textbox->carets[0] = textbox->bytes;
+ UITextboxReplace(textbox, "", 0, sendChangedMessage);
+}
+
+void UITextboxMoveCaret(UITextbox *textbox, bool backward, bool word) {
+ while (true) {
+ if (textbox->carets[0] > 0 && backward) {
+ textbox->carets[0]--;
+ } else if (textbox->carets[0] < textbox->bytes && !backward) {
+ textbox->carets[0]++;
+ } else {
+ return;
+ }
+
+ if (!word) {
+ return;
+ } else if (textbox->carets[0] != textbox->bytes && textbox->carets[0] != 0) {
+ char c1 = textbox->string[textbox->carets[0] - 1];
+ char c2 = textbox->string[textbox->carets[0]];
+
+ if (_UICharIsAlphaOrDigitOrUnderscore(c1) != _UICharIsAlphaOrDigitOrUnderscore(c2)) {
+ return;
+ }
+ }
+ }
+}
+
+int _UITextboxMessage(UIElement *element, UIMessage message, int di, void *dp) {
+ UITextbox *textbox = (UITextbox *) element;
+
+ if (message == UI_MSG_GET_HEIGHT) {
+ return UI_SIZE_TEXTBOX_HEIGHT * element->window->scale;
+ } else if (message == UI_MSG_GET_WIDTH) {
+ return UI_SIZE_TEXTBOX_WIDTH * element->window->scale;
+ } else if (message == UI_MSG_PAINT) {
+ int scaledMargin = UI_SIZE_TEXTBOX_MARGIN * element->window->scale;
+ int totalWidth = UIMeasureStringWidth(textbox->string, textbox->bytes) + scaledMargin * 2;
+ UIRectangle textBounds = UIRectangleAdd(element->bounds, UI_RECT_1I(scaledMargin));
+
+ if (textbox->scroll > totalWidth - UI_RECT_WIDTH(textBounds)) {
+ textbox->scroll = totalWidth - UI_RECT_WIDTH(textBounds);
+ }
+
+ if (textbox->scroll < 0) {
+ textbox->scroll = 0;
+ }
+
+ int caretX = UIMeasureStringWidth(textbox->string, textbox->carets[0]) - textbox->scroll;
+
+ if (caretX < 0) {
+ textbox->scroll = caretX + textbox->scroll;
+ } else if (caretX > UI_RECT_WIDTH(textBounds)) {
+ textbox->scroll = caretX - UI_RECT_WIDTH(textBounds) + textbox->scroll + 1;
+ }
+
+ UIPainter *painter = (UIPainter *) dp;
+ bool focused = element->window->focused == element;
+ bool disabled = element->flags & UI_ELEMENT_DISABLED;
+ UIDrawRectangle(painter, element->bounds,
+ disabled ? ui.theme.buttonDisabled : focused ? ui.theme.textboxFocused : ui.theme.textboxNormal,
+ ui.theme.border, UI_RECT_1(1));
+#ifdef __cplusplus
+ UIStringSelection selection = {};
+#else
+ UIStringSelection selection = { 0 };
+#endif
+ selection.carets[0] = textbox->carets[0];
+ selection.carets[1] = textbox->carets[1];
+ selection.colorBackground = ui.theme.selected;
+ selection.colorText = ui.theme.textSelected;
+ textBounds.l -= textbox->scroll;
+ UIDrawString(painter, textBounds, textbox->string, textbox->bytes,
+ disabled ? ui.theme.textDisabled : ui.theme.text, UI_ALIGN_LEFT, focused ? &selection : NULL);
+ } else if (message == UI_MSG_GET_CURSOR) {
+ return UI_CURSOR_TEXT;
+ } else if (message == UI_MSG_LEFT_DOWN) {
+ UIElementFocus(element);
+ } else if (message == UI_MSG_UPDATE) {
+ UIElementRepaint(element, NULL);
+ } else if (message == UI_MSG_DESTROY) {
+ UI_FREE(textbox->string);
+ } else if (message == UI_MSG_KEY_TYPED) {
+ UIKeyTyped *m = (UIKeyTyped *) dp;
+ bool handled = true;
+
+ if (textbox->rejectNextKey) {
+ textbox->rejectNextKey = false;
+ handled = false;
+ } else if (m->code == UI_KEYCODE_BACKSPACE || m->code == UI_KEYCODE_DELETE) {
+ if (textbox->carets[0] == textbox->carets[1]) {
+ UITextboxMoveCaret(textbox, m->code == UI_KEYCODE_BACKSPACE, element->window->ctrl);
+ }
+
+ UITextboxReplace(textbox, NULL, 0, true);
+ } else if (m->code == UI_KEYCODE_LEFT || m->code == UI_KEYCODE_RIGHT) {
+ UITextboxMoveCaret(textbox, m->code == UI_KEYCODE_LEFT, element->window->ctrl);
+
+ if (!element->window->shift) {
+ textbox->carets[1] = textbox->carets[0];
+ }
+ } else if (m->code == UI_KEYCODE_HOME || m->code == UI_KEYCODE_END) {
+ if (m->code == UI_KEYCODE_HOME) {
+ textbox->carets[0] = 0;
+ } else {
+ textbox->carets[0] = textbox->bytes;
+ }
+
+ if (!element->window->shift) {
+ textbox->carets[1] = textbox->carets[0];
+ }
+ } else if (m->code == UI_KEYCODE_LETTER('A') && element->window->ctrl) {
+ textbox->carets[1] = 0;
+ textbox->carets[0] = textbox->bytes;
+ } else if (m->textBytes && !element->window->alt && !element->window->ctrl && m->text[0] >= 0x20) {
+ UITextboxReplace(textbox, m->text, m->textBytes, true);
+ } else if ((m->code == UI_KEYCODE_LETTER('C') || m->code == UI_KEYCODE_LETTER('X') || m->code == UI_KEYCODE_INSERT)
+ && element->window->ctrl && !element->window->alt && !element->window->shift) {
+ int to = textbox->carets[0] > textbox->carets[1] ? textbox->carets[0] : textbox->carets[1];
+ int from = textbox->carets[0] < textbox->carets[1] ? textbox->carets[0] : textbox->carets[1];
+
+ if (from != to) {
+ char *pasteText = (char *) UI_CALLOC(to - from + 1);
+ for (int i = from; i < to; i++) pasteText[i - from] = textbox->string[i];
+ _UIClipboardWriteText(element->window, pasteText);
+ }
+
+ if (m->code == UI_KEYCODE_LETTER('X')) {
+ UITextboxReplace(textbox, NULL, 0, true);
+ }
+ } else if ((m->code == UI_KEYCODE_LETTER('V') && element->window->ctrl && !element->window->alt && !element->window->shift)
+ || (m->code == UI_KEYCODE_INSERT && !element->window->ctrl && !element->window->alt && element->window->shift)) {
+ size_t bytes;
+ char *text = _UIClipboardReadTextStart(element->window, &bytes);
+ if (text) UITextboxReplace(textbox, text, bytes, true);
+ _UIClipboardReadTextEnd(element->window, text);
+ } else {
+ handled = false;
+ }
+
+ if (handled) {
+ UIElementRepaint(element, NULL);
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+UITextbox *UITextboxCreate(UIElement *parent, uint32_t flags) {
+ return (UITextbox *) UIElementCreate(sizeof(UITextbox), parent, flags | UI_ELEMENT_TAB_STOP, _UITextboxMessage, "Textbox");
+}
+
+int _UIColorCircleMessage(UIElement *element, UIMessage message, int di, void *dp) {
+ UIColorPicker *colorPicker = (UIColorPicker *) element->parent;
+
+ if (message == UI_MSG_PAINT) {
+ UIPainter *painter = (UIPainter *) dp;
+
+ int startY = element->bounds.t, endY = element->bounds.b;
+ int startX = element->bounds.l, endX = element->bounds.r;
+ int size = endY - startY;
+
+ for (int i = startY; i < endY; i++) {
+ uint32_t *out = painter->bits + i * painter->width + startX;
+ int j = startX;
+ float y0 = i - startY - size / 2, x0 = -size / 2;
+ float angle = _UIArcTan2Float((i - startY) * 2.0f / size - 1, -1);
+
+ do {
+ float distanceFromCenterSquared = x0 * x0 + y0 * y0;
+ float hue = (angle + 3.14159f) * 0.954929658f;
+ float saturation = _UISquareRootFloat(distanceFromCenterSquared * 4.0f / size / size);
+
+ if (saturation <= 1 && UIRectangleContains(painter->clip, j, i)) {
+ UIColorToRGB(hue, saturation, colorPicker->value, out);
+ *out |= 0xFF000000;
+ }
+
+ out++, j++, x0++;
+
+ if (distanceFromCenterSquared) {
+ angle -= y0 / distanceFromCenterSquared;
+ } else {
+ angle = _UIArcTan2Float((i - startY) * 2.0f / size - 1, 0.01f);
+ }
+ } while (j < endX);
+ }
+
+ float angle = colorPicker->hue / 0.954929658f - 3.14159f;
+ float radius = colorPicker->saturation * size / 2;
+ int cx = (startX + endX) / 2 + radius * _UICosFloat(angle);
+ int cy = (startY + endY) / 2 + radius * _UISinFloat(angle);
+ UIDrawInvert(painter, UI_RECT_4(cx - 1, cx + 1, startY, endY));
+ UIDrawInvert(painter, UI_RECT_4(startX, endX, cy - 1, cy + 1));
+ } else if (message == UI_MSG_GET_CURSOR) {
+ return UI_CURSOR_CROSS_HAIR;
+ } else if (message == UI_MSG_LEFT_DOWN || message == UI_MSG_MOUSE_DRAG) {
+ int startY = element->bounds.t, endY = element->bounds.b, cursorY = element->window->cursorY;
+ int startX = element->bounds.l, endX = element->bounds.r, cursorX = element->window->cursorX;
+ int dx = (startX + endX) / 2, dy = (startY + endY) / 2;
+ int size = endY - startY;
+
+ float angle = _UIArcTan2Float((cursorY - startY) * 2.0f / size - 1, (cursorX - startX) * 2.0f / size - 1);
+ float distanceFromCenterSquared = (cursorX - dx) * (cursorX - dx) + (cursorY - dy) * (cursorY - dy);
+ colorPicker->hue = (angle + 3.14159f) * 0.954929658f;
+ colorPicker->saturation = _UISquareRootFloat(distanceFromCenterSquared * 4.0f / size / size);;
+ if (colorPicker->saturation > 1) colorPicker->saturation = 1;
+
+ UIElementMessage(&colorPicker->e, UI_MSG_VALUE_CHANGED, 0, 0);
+ UIElementRepaint(&colorPicker->e, NULL);
+ }
+
+ return 0;
+}
+
+int _UIColorSliderMessage(UIElement *element, UIMessage message, int di, void *dp) {
+ UIColorPicker *colorPicker = (UIColorPicker *) element->parent;
+ float opacitySlider = element->flags & 1;
+
+ if (message == UI_MSG_PAINT) {
+ UIPainter *painter = (UIPainter *) dp;
+
+ int startY = element->bounds.t, endY = element->bounds.b;
+ int startX = element->bounds.l, endX = element->bounds.r;
+ int size = endY - startY;
+
+ for (int i = startY; i < endY; i++) {
+ if (i < painter->clip.t || i >= painter->clip.b) continue;
+ uint32_t *out = painter->bits + i * painter->width + startX;
+ int j = element->clip.l;
+ uint32_t color;
+ float p = 1.0f - (float) (i - startY) / size;
+
+ if (opacitySlider) {
+ UIColorToRGB(colorPicker->hue, colorPicker->saturation, colorPicker->value, &color);
+ color = UI_COLOR_FROM_FLOAT(p * (UI_COLOR_RED_F(color) - 0.5f) + 0.5f,
+ p * (UI_COLOR_GREEN_F(color) - 0.5f) + 0.5f,
+ p * (UI_COLOR_BLUE_F(color) - 0.5f) + 0.5f);
+ } else {
+ UIColorToRGB(colorPicker->hue, colorPicker->saturation, p, &color);
+ }
+
+ color |= 0xFF000000;
+
+ do {
+ *out = color;
+ out++, j++;
+ } while (j < element->clip.r);
+ }
+
+ int cy = (size - 1) * (1 - (opacitySlider ? colorPicker->opacity : colorPicker->value)) + startY;
+ UIDrawInvert(painter, UI_RECT_4(startX, endX, cy - 1, cy + 1));
+ } else if (message == UI_MSG_GET_CURSOR) {
+ return UI_CURSOR_CROSS_HAIR;
+ } else if (message == UI_MSG_LEFT_DOWN || message == UI_MSG_MOUSE_DRAG) {
+ int startY = element->bounds.t, endY = element->bounds.b, cursorY = element->window->cursorY;
+ float *value = opacitySlider ? &colorPicker->opacity : &colorPicker->value;
+ *value = 1 - (float) (cursorY - startY) / (endY - startY);
+ if (*value < 0) *value = 0;
+ if (*value > 1) *value = 1;
+ UIElementMessage(&colorPicker->e, UI_MSG_VALUE_CHANGED, 0, 0);
+ UIElementRepaint(&colorPicker->e, NULL);
+ }
+
+ return 0;
+}
+
+int _UIColorPickerMessage(UIElement *element, UIMessage message, int di, void *dp) {
+ bool hasOpacity = element->flags & UI_COLOR_PICKER_HAS_OPACITY;
+
+ if (message == UI_MSG_GET_WIDTH) {
+ return (hasOpacity ? 280 : 240) * element->window->scale;
+ } else if (message == UI_MSG_GET_HEIGHT) {
+ return 200 * element->window->scale;
+ } else if (message == UI_MSG_LAYOUT) {
+ UIRectangle bounds = element->bounds;
+
+ int sliderSize = 35 * element->window->scale;
+ int gap = 5 * element->window->scale;
+
+ if (hasOpacity) {
+ UIElementMove(element->children, UI_RECT_4(bounds.l, bounds.r - (sliderSize + gap) * 2, bounds.t, bounds.b), false);
+ UIElementMove(element->children->next, UI_RECT_4(bounds.r - sliderSize * 2 - gap, bounds.r - sliderSize - gap, bounds.t, bounds.b), false);
+ UIElementMove(element->children->next->next, UI_RECT_4(bounds.r - sliderSize, bounds.r, bounds.t, bounds.b), false);
+ } else {
+ UIElementMove(element->children, UI_RECT_4(bounds.l, bounds.r - sliderSize - gap, bounds.t, bounds.b), false);
+ UIElementMove(element->children->next, UI_RECT_4(bounds.r - sliderSize, bounds.r, bounds.t, bounds.b), false);
+ }
+ }
+
+ return 0;
+}
+
+UIColorPicker *UIColorPickerCreate(UIElement *parent, uint32_t flags) {
+ UIColorPicker *colorPicker = (UIColorPicker *) UIElementCreate(sizeof(UIColorPicker), parent, flags, _UIColorPickerMessage, "ColorPicker");
+ UIElementCreate(sizeof(UIElement), &colorPicker->e, 0, _UIColorCircleMessage, "ColorCircle");
+ UIElementCreate(sizeof(UIElement), &colorPicker->e, 0, _UIColorSliderMessage, "ColorSlider");
+
+ if (flags & UI_COLOR_PICKER_HAS_OPACITY) {
+ UIElementCreate(sizeof(UIElement), &colorPicker->e, 1, _UIColorSliderMessage, "ColorSlider");
+ }
+
+ return colorPicker;
+}
+
+#define UI_MDI_CHILD_CALCULATE_LAYOUT() \
+ int titleSize = UI_SIZE_MDI_CHILD_TITLE * element->window->scale; \
+ int borderSize = UI_SIZE_MDI_CHILD_BORDER * element->window->scale; \
+ UIRectangle title = UIRectangleAdd(element->bounds, UI_RECT_4(borderSize, -borderSize, 0, 0)); \
+ title.b = title.t + titleSize; \
+ UIRectangle content = UIRectangleAdd(element->bounds, UI_RECT_4(borderSize, -borderSize, titleSize, -borderSize));
+
+int _UIMDIChildHitTest(UIMDIChild *mdiChild, int x, int y) {
+ UIElement *element = &mdiChild->e;
+ UI_MDI_CHILD_CALCULATE_LAYOUT();
+ int cornerSize = UI_SIZE_MDI_CHILD_CORNER * element->window->scale;
+ if (!UIRectangleContains(element->bounds, x, y) || UIRectangleContains(content, x, y)) return -1;
+ else if (x < element->bounds.l + cornerSize && y < element->bounds.t + cornerSize) return 0b1010;
+ else if (x > element->bounds.r - cornerSize && y < element->bounds.t + cornerSize) return 0b0110;
+ else if (x < element->bounds.l + cornerSize && y > element->bounds.b - cornerSize) return 0b1001;
+ else if (x > element->bounds.r - cornerSize && y > element->bounds.b - cornerSize) return 0b0101;
+ else if (x < element->bounds.l + borderSize) return 0b1000;
+ else if (x > element->bounds.r - borderSize) return 0b0100;
+ else if (y < element->bounds.t + borderSize) return 0b0010;
+ else if (y > element->bounds.b - borderSize) return 0b0001;
+ else if (UIRectangleContains(title, x, y)) return 0b1111;
+ else return -1;
+}
+
+void _UIMDIChildCloseButton(void *_child) {
+ UIElement *child = (UIElement *) _child;
+
+ if (!UIElementMessage(child, UI_MSG_WINDOW_CLOSE, 0, 0)) {
+ UIElementDestroy(child);
+ UIElementRefresh(child->parent);
+ }
+}
+
+int _UIMDIChildMessage(UIElement *element, UIMessage message, int di, void *dp) {
+ UIMDIChild *mdiChild = (UIMDIChild *) element;
+
+ if (message == UI_MSG_PAINT) {
+ UI_MDI_CHILD_CALCULATE_LAYOUT();
+ UIPainter *painter = (UIPainter *) dp;
+ UIRectangle borders = UI_RECT_4(borderSize, borderSize, titleSize, borderSize);
+ UIDrawBorder(painter, element->bounds, ui.theme.buttonNormal, borders);
+ UIDrawBorder(painter, element->bounds, ui.theme.border, UI_RECT_1((int) element->window->scale));
+ UIDrawBorder(painter, UIRectangleAdd(content, UI_RECT_1I(-1)), ui.theme.border, UI_RECT_1((int) element->window->scale));
+ UIDrawString(painter, title, mdiChild->title, mdiChild->titleBytes, ui.theme.text, UI_ALIGN_LEFT, NULL);
+ } else if (message == UI_MSG_GET_WIDTH) {
+ UIElement *child = element->children;
+ while (child && child->next) child = child->next;
+ int width = 2 * UI_SIZE_MDI_CHILD_BORDER;
+ width += (child ? UIElementMessage(child, message, di ? (di - UI_SIZE_MDI_CHILD_TITLE + UI_SIZE_MDI_CHILD_BORDER) : 0, dp) : 0);
+ if (width < UI_SIZE_MDI_CHILD_MINIMUM_WIDTH) width = UI_SIZE_MDI_CHILD_MINIMUM_WIDTH;
+ return width;
+ } else if (message == UI_MSG_GET_HEIGHT) {
+ UIElement *child = element->children;
+ while (child && child->next) child = child->next;
+ int height = UI_SIZE_MDI_CHILD_TITLE + UI_SIZE_MDI_CHILD_BORDER;
+ height += (child ? UIElementMessage(child, message, di ? (di - 2 * UI_SIZE_MDI_CHILD_BORDER) : 0, dp) : 0);
+ if (height < UI_SIZE_MDI_CHILD_MINIMUM_HEIGHT) height = UI_SIZE_MDI_CHILD_MINIMUM_HEIGHT;
+ return height;
+ } else if (message == UI_MSG_LAYOUT) {
+ UI_MDI_CHILD_CALCULATE_LAYOUT();
+
+ UIElement *child = element->children;
+ int position = title.r;
+
+ while (child && child->next) {
+ int width = UIElementMessage(child, UI_MSG_GET_WIDTH, 0, 0);
+ UIElementMove(child, UI_RECT_4(position - width, position, title.t, title.b), false);
+ position -= width, child = child->next;
+ }
+
+ if (child) {
+ UIElementMove(child, content, false);
+ }
+ } else if (message == UI_MSG_GET_CURSOR) {
+ int hitTest = _UIMDIChildHitTest(mdiChild, element->window->cursorX, element->window->cursorY);
+ if (hitTest == 0b1000) return UI_CURSOR_RESIZE_LEFT;
+ if (hitTest == 0b0010) return UI_CURSOR_RESIZE_UP;
+ if (hitTest == 0b0110) return UI_CURSOR_RESIZE_UP_RIGHT;
+ if (hitTest == 0b1010) return UI_CURSOR_RESIZE_UP_LEFT;
+ if (hitTest == 0b0100) return UI_CURSOR_RESIZE_RIGHT;
+ if (hitTest == 0b0001) return UI_CURSOR_RESIZE_DOWN;
+ if (hitTest == 0b1001) return UI_CURSOR_RESIZE_DOWN_LEFT;
+ if (hitTest == 0b0101) return UI_CURSOR_RESIZE_DOWN_RIGHT;
+ return UI_CURSOR_ARROW;
+ } else if (message == UI_MSG_LEFT_DOWN) {
+ mdiChild->dragHitTest = _UIMDIChildHitTest(mdiChild, element->window->cursorX, element->window->cursorY);
+ mdiChild->dragOffset = UIRectangleAdd(element->bounds, UI_RECT_2(-element->window->cursorX, -element->window->cursorY));
+ } else if (message == UI_MSG_LEFT_UP) {
+ if (mdiChild->bounds.l < 0) mdiChild->bounds.r -= mdiChild->bounds.l, mdiChild->bounds.l = 0;
+ if (mdiChild->bounds.t < 0) mdiChild->bounds.b -= mdiChild->bounds.t, mdiChild->bounds.t = 0;
+ UIElementRefresh(element->parent);
+ } else if (message == UI_MSG_MOUSE_DRAG) {
+ if (mdiChild->dragHitTest > 0) {
+#define _UI_MDI_CHILD_MOVE_EDGE(bit, edge, cursor, size, opposite, negate, minimum, offset) \
+ if (mdiChild->dragHitTest & bit) mdiChild->bounds.edge = mdiChild->dragOffset.edge + element->window->cursor - element->parent->bounds.offset; \
+ if ((mdiChild->dragHitTest & bit) && size(mdiChild->bounds) < minimum) mdiChild->bounds.edge = mdiChild->bounds.opposite negate minimum;
+ _UI_MDI_CHILD_MOVE_EDGE(0b1000, l, cursorX, UI_RECT_WIDTH, r, -, UI_SIZE_MDI_CHILD_MINIMUM_WIDTH, l);
+ _UI_MDI_CHILD_MOVE_EDGE(0b0100, r, cursorX, UI_RECT_WIDTH, l, +, UI_SIZE_MDI_CHILD_MINIMUM_WIDTH, l);
+ _UI_MDI_CHILD_MOVE_EDGE(0b0010, t, cursorY, UI_RECT_HEIGHT, b, -, UI_SIZE_MDI_CHILD_MINIMUM_HEIGHT, t);
+ _UI_MDI_CHILD_MOVE_EDGE(0b0001, b, cursorY, UI_RECT_HEIGHT, t, +, UI_SIZE_MDI_CHILD_MINIMUM_HEIGHT, t);
+ UIElementRefresh(element->parent);
+ }
+ } else if (message == UI_MSG_DESTROY) {
+ UI_FREE(mdiChild->title);
+ UIMDIClient *client = (UIMDIClient *) element->parent;
+ if (client->e.children == element) client->e.children = element->next;
+ if (mdiChild->previous) mdiChild->previous->e.next = element->next;
+ if (element->next) ((UIMDIChild *) element->next)->previous = mdiChild->previous;
+ if (client->active == mdiChild) client->active = mdiChild->previous;
+ }
+
+ return 0;
+}
+
+int _UIMDIClientMessage(UIElement *element, UIMessage message, int di, void *dp) {
+ UIMDIClient *client = (UIMDIClient *) element;
+
+ if (message == UI_MSG_PAINT) {
+ UIDrawBlock((UIPainter *) dp, element->bounds, (element->flags & UI_MDI_CLIENT_TRANSPARENT) ? 0 : ui.theme.panel2);
+ } else if (message == UI_MSG_LAYOUT) {
+ UIElement *child = element->children;
+
+ while (child) {
+ UI_ASSERT(child->messageClass == _UIMDIChildMessage);
+
+ UIMDIChild *mdiChild = (UIMDIChild *) child;
+
+ if (UIRectangleEquals(mdiChild->bounds, UI_RECT_1(0))) {
+ int width = UIElementMessage(&mdiChild->e, UI_MSG_GET_WIDTH, 0, 0);
+ int height = UIElementMessage(&mdiChild->e, UI_MSG_GET_HEIGHT, width, 0);
+ if (client->cascade + width > element->bounds.r || client->cascade + height > element->bounds.b) client->cascade = 0;
+ mdiChild->bounds = UI_RECT_4(client->cascade, client->cascade + width, client->cascade, client->cascade + height);
+ client->cascade += UI_SIZE_MDI_CASCADE * element->window->scale;
+ }
+
+ UIRectangle bounds = UIRectangleAdd(mdiChild->bounds, UI_RECT_2(element->bounds.l, element->bounds.t));
+ UIElementMove(child, bounds, false);
+ child = child->next;
+ }
+ } else if (message == UI_MSG_FIND_BY_POINT) {
+ UIFindByPoint *m = (UIFindByPoint *) dp;
+ UIMDIChild *child = client->active;
+
+ while (child) {
+ if (UIRectangleContains(child->e.bounds, m->x, m->y)) {
+ m->result = UIElementFindByPoint(&child->e, m->x, m->y);
+ return 1;
+ }
+
+ child = child->previous;
+ }
+
+ return 1;
+ } else if (message == UI_MSG_PRESSED_DESCENDENT) {
+ UIMDIChild *child = (UIMDIChild *) dp;
+
+ if (child && child != client->active) {
+ if (client->e.children == &child->e) client->e.children = child->e.next;
+ if (child->previous) child->previous->e.next = child->e.next;
+ if (child->e.next) ((UIMDIChild *) child->e.next)->previous = child->previous;
+ if (client->active) client->active->e.next = &child->e;
+ child->previous = client->active;
+ child->e.next = NULL;
+ client->active = child;
+ ((UIMDIChild *) client->e.children)->previous = NULL;
+ UIElementRefresh(element);
+ }
+ }
+
+ return 0;
+}
+
+UIMDIChild *UIMDIChildCreate(UIElement *parent, uint32_t flags, UIRectangle initialBounds, const char *title, ptrdiff_t titleBytes) {
+ UI_ASSERT(parent->messageClass == _UIMDIClientMessage);
+
+ UIMDIChild *mdiChild = (UIMDIChild *) UIElementCreate(sizeof(UIMDIChild), parent, flags, _UIMDIChildMessage, "MDIChild");
+ UIMDIClient *mdiClient = (UIMDIClient *) parent;
+
+ mdiChild->bounds = initialBounds;
+ mdiChild->title = UIStringCopy(title, (mdiChild->titleBytes = titleBytes));
+ mdiChild->previous = mdiClient->active;
+ mdiClient->active = mdiChild;
+
+ if (flags & UI_MDI_CHILD_CLOSE_BUTTON) {
+ UIButton *closeButton = UIButtonCreate(&mdiChild->e, UI_BUTTON_SMALL | UI_ELEMENT_NON_CLIENT, "X", 1);
+ closeButton->invoke = _UIMDIChildCloseButton;
+ closeButton->e.cp = mdiChild;
+ }
+
+ return mdiChild;
+}
+
+UIMDIClient *UIMDIClientCreate(UIElement *parent, uint32_t flags) {
+ return (UIMDIClient *) UIElementCreate(sizeof(UIMDIClient), parent, flags, _UIMDIClientMessage, "MDIClient");
+}
+
+int _UIExpandPaneMessage(UIElement *element, UIMessage message, int di, void *dp) {
+ UIExpandPane *pane = (UIExpandPane *) element;
+
+ if (message == UI_MSG_GET_HEIGHT) {
+ int height = UIElementMessage(&pane->button->e, message, di, dp);
+
+ if (pane->expanded) {
+ height += UIElementMessage(&pane->panel->e, message, di, dp);
+ }
+
+ return height;
+ } else if (message == UI_MSG_LAYOUT) {
+ UIRectangle bounds = pane->e.bounds;
+ int buttonHeight = UIElementMessage(&pane->button->e, UI_MSG_GET_HEIGHT, UI_RECT_WIDTH(bounds), NULL);
+ UIElementMove(&pane->button->e, UI_RECT_4(bounds.l, bounds.r, bounds.t, bounds.t + buttonHeight), false);
+
+ if (pane->expanded) {
+ pane->panel->e.flags &= ~UI_ELEMENT_HIDE;
+ UIElementMove(&pane->panel->e, UI_RECT_4(bounds.l, bounds.r, bounds.t + buttonHeight, bounds.b), false);
+ } else {
+ pane->panel->e.flags |= UI_ELEMENT_HIDE;
+ }
+ } else if (message == UI_MSG_CLIENT_PARENT) {
+ *(UIElement **) dp = &pane->panel->e;
+ }
+
+ return 0;
+}
+
+void _UIExpandPaneButtonInvoke(void *cp) {
+ UIExpandPane *pane = (UIExpandPane *) cp;
+ pane->expanded = !pane->expanded;
+ if (pane->expanded) pane->button->e.flags |= UI_BUTTON_CHECKED;
+ else pane->button->e.flags &= ~UI_BUTTON_CHECKED;
+
+ UIElement *ancestor = &pane->e;
+
+ while (ancestor) {
+ UIElementRefresh(ancestor);
+
+ if ((ancestor->messageClass == _UIPanelMessage && (ancestor->flags & UI_PANEL_SCROLL))
+ || (ancestor->messageClass == _UIMDIChildMessage)
+ || (ancestor->flags & UI_ELEMENT_V_FILL)) {
+ break;
+ }
+
+ ancestor = ancestor->parent;
+ }
+}
+
+UIExpandPane *UIExpandPaneCreate(UIElement *parent, uint32_t flags, const char *label, ptrdiff_t labelBytes, uint32_t panelFlags) {
+ UIExpandPane *pane = (UIExpandPane *) UIElementCreate(sizeof(UIExpandPane), parent, flags, _UIExpandPaneMessage, "ExpandPane");
+ pane->button = UIButtonCreate(parent, UI_ELEMENT_NON_CLIENT, label, labelBytes);
+ pane->button->e.cp = pane;
+ pane->button->invoke = _UIExpandPaneButtonInvoke;
+ pane->panel = UIPanelCreate(parent, UI_ELEMENT_NON_CLIENT | panelFlags);
+ return pane;
+}
+
+void _UIImageDisplayUpdateViewport(UIImageDisplay *display) {
+ UIRectangle bounds = display->e.bounds;
+ bounds.r -= bounds.l, bounds.b -= bounds.t;
+
+ float minimumZoomX = 1, minimumZoomY = 1;
+ if (display->width > bounds.r) minimumZoomX = (float) bounds.r / display->width;
+ if (display->height > bounds.b) minimumZoomY = (float) bounds.b / display->height;
+ float minimumZoom = minimumZoomX < minimumZoomY ? minimumZoomX : minimumZoomY;
+
+ if (display->zoom < minimumZoom || (display->e.flags & _UI_IMAGE_DISPLAY_ZOOM_FIT)) {
+ display->zoom = minimumZoom;
+ display->e.flags |= _UI_IMAGE_DISPLAY_ZOOM_FIT;
+ }
+
+ if (display->panX < 0) display->panX = 0;
+ if (display->panY < 0) display->panY = 0;
+ if (display->panX > display->width - bounds.r / display->zoom) display->panX = display->width - bounds.r / display->zoom;
+ if (display->panY > display->height - bounds.b / display->zoom) display->panY = display->height - bounds.b / display->zoom;
+
+ if (bounds.r && display->width * display->zoom <= bounds.r) display->panX = display->width / 2 - bounds.r / display->zoom / 2;
+ if (bounds.b && display->height * display->zoom <= bounds.b) display->panY = display->height / 2 - bounds.b / display->zoom / 2;
+}
+
+int _UIImageDisplayMessage(UIElement *element, UIMessage message, int di, void *dp) {
+ UIImageDisplay *display = (UIImageDisplay *) element;
+
+ if (message == UI_MSG_GET_HEIGHT) {
+ return display->height;
+ } else if (message == UI_MSG_GET_WIDTH) {
+ return display->width;
+ } else if (message == UI_MSG_DESTROY) {
+ UI_FREE(display->bits);
+ } else if (message == UI_MSG_PAINT) {
+ UIPainter *painter = (UIPainter *) dp;
+
+ int w = UI_RECT_WIDTH(element->bounds), h = UI_RECT_HEIGHT(element->bounds);
+ int x = _UILinearMap(0, display->panX, display->panX + w / display->zoom, 0, w) + element->bounds.l;
+ int y = _UILinearMap(0, display->panY, display->panY + h / display->zoom, 0, h) + element->bounds.t;
+
+ UIRectangle image = UI_RECT_4(x, x + (int) (display->width * display->zoom), y, (int) (y + display->height * display->zoom));
+ UIRectangle bounds = UIRectangleIntersection(painter->clip, UIRectangleIntersection(display->e.bounds, image));
+ if (!UI_RECT_VALID(bounds)) return 0;
+
+ if (display->zoom == 1) {
+ uint32_t *lineStart = (uint32_t *) painter->bits + bounds.t * painter->width + bounds.l;
+ uint32_t *sourceLineStart = display->bits + (bounds.l - image.l) + display->width * (bounds.t - image.t);
+
+ for (int i = 0; i < bounds.b - bounds.t; i++, lineStart += painter->width, sourceLineStart += display->width) {
+ uint32_t *destination = lineStart;
+ uint32_t *source = sourceLineStart;
+ int j = bounds.r - bounds.l;
+
+ do {
+ *destination = *source;
+ destination++;
+ source++;
+ } while (--j);
+ }
+ } else {
+ float zr = 1.0f / display->zoom;
+ uint32_t *destination = (uint32_t *) painter->bits;
+
+ for (int i = bounds.t; i < bounds.b; i++) {
+ int ty = (i - image.t) * zr;
+
+ for (int j = bounds.l; j < bounds.r; j++) {
+ int tx = (j - image.l) * zr;
+ destination[i * painter->width + j] = display->bits[ty * display->width + tx];
+ }
+ }
+ }
+ } else if (message == UI_MSG_MOUSE_WHEEL && (element->flags & UI_IMAGE_DISPLAY_INTERACTIVE)) {
+ display->e.flags &= ~_UI_IMAGE_DISPLAY_ZOOM_FIT;
+ int divisions = -di / 72;
+ float factor = 1;
+ float perDivision = element->window->ctrl ? 2.0f : element->window->alt ? 1.01f : 1.2f;
+ while (divisions > 0) factor *= perDivision, divisions--;
+ while (divisions < 0) factor /= perDivision, divisions++;
+ if (display->zoom * factor > 64) factor = 64 / display->zoom;
+ int mx = element->window->cursorX - element->bounds.l;
+ int my = element->window->cursorY - element->bounds.t;
+ display->zoom *= factor;
+ display->panX -= mx / display->zoom * (1 - factor);
+ display->panY -= my / display->zoom * (1 - factor);
+ _UIImageDisplayUpdateViewport(display);
+ UIElementRepaint(&display->e, NULL);
+ } else if (message == UI_MSG_LAYOUT && (element->flags & UI_IMAGE_DISPLAY_INTERACTIVE)) {
+ UIRectangle bounds = display->e.bounds;
+ bounds.r -= bounds.l, bounds.b -= bounds.t;
+ display->panX -= (bounds.r - display->previousWidth ) / 2 / display->zoom;
+ display->panY -= (bounds.b - display->previousHeight) / 2 / display->zoom;
+ display->previousWidth = bounds.r, display->previousHeight = bounds.b;
+ _UIImageDisplayUpdateViewport(display);
+ } else if (message == UI_MSG_GET_CURSOR && (element->flags & UI_IMAGE_DISPLAY_INTERACTIVE)
+ && (UI_RECT_WIDTH(element->bounds) < display->width * display->zoom
+ || UI_RECT_HEIGHT(element->bounds) < display->height * display->zoom)) {
+ return UI_CURSOR_HAND;
+ } else if (message == UI_MSG_MOUSE_DRAG) {
+ display->panX -= (element->window->cursorX - display->previousPanPointX) / display->zoom;
+ display->panY -= (element->window->cursorY - display->previousPanPointY) / display->zoom;
+ _UIImageDisplayUpdateViewport(display);
+ display->previousPanPointX = element->window->cursorX;
+ display->previousPanPointY = element->window->cursorY;
+ UIElementRepaint(element, NULL);
+ } else if (message == UI_MSG_LEFT_DOWN) {
+ display->e.flags &= ~_UI_IMAGE_DISPLAY_ZOOM_FIT;
+ display->previousPanPointX = element->window->cursorX;
+ display->previousPanPointY = element->window->cursorY;
+ }
+
+ return 0;
+}
+
+void UIImageDisplaySetContent(UIImageDisplay *display, uint32_t *bits, size_t width, size_t height, size_t stride) {
+ UI_FREE(display->bits);
+
+ display->bits = (uint32_t *) UI_MALLOC(width * height * 4);
+ display->width = width;
+ display->height = height;
+
+ uint32_t *destination = display->bits;
+ uint32_t *source = bits;
+
+ for (uintptr_t row = 0; row < height; row++, source += stride / 4) {
+ for (uintptr_t i = 0; i < width; i++) {
+ *destination++ = source[i];
+ }
+ }
+}
+
+UIImageDisplay *UIImageDisplayCreate(UIElement *parent, uint32_t flags, uint32_t *bits, size_t width, size_t height, size_t stride) {
+ UIImageDisplay *display = (UIImageDisplay *) UIElementCreate(sizeof(UIImageDisplay), parent, flags, _UIImageDisplayMessage, "ImageDisplay");
+ display->zoom = 1.0f;
+ UIImageDisplaySetContent(display, bits, width, height, stride);
+ return display;
+}
+
+int _UIDialogWrapperMessage(UIElement *element, UIMessage message, int di, void *dp) {
+ if (message == UI_MSG_LAYOUT) {
+ int width = UIElementMessage(element->children, UI_MSG_GET_WIDTH, 0, 0);
+ int height = UIElementMessage(element->children, UI_MSG_GET_HEIGHT, width, 0);
+ int cx = (element->bounds.l + element->bounds.r) / 2;
+ int cy = (element->bounds.t + element->bounds.b) / 2;
+ UIRectangle bounds = UI_RECT_4(cx - (width + 1) / 2, cx + width / 2, cy - (height + 1) / 2, cy + height / 2);
+ UIElementMove(element->children, bounds, false);
+ UIElementRepaint(element, NULL);
+ } else if (message == UI_MSG_PAINT) {
+ UIRectangle bounds = UIRectangleAdd(element->children->bounds, UI_RECT_1I(-1));
+ UIDrawBorder((UIPainter *) dp, bounds, ui.theme.border, UI_RECT_1(1));
+ UIDrawBorder((UIPainter *) dp, UIRectangleAdd(bounds, UI_RECT_1(1)), ui.theme.border, UI_RECT_1(1));
+ } else if (message == UI_MSG_KEY_TYPED) {
+ UIKeyTyped *typed = (UIKeyTyped *) dp;
+
+ if (element->window->ctrl) return 0;
+ if (element->window->shift) return 0;
+
+ char c0 = 0, c1 = 0;
+
+ if (typed->textBytes == 1 && typed->text[0] >= 'a' && typed->text[0] <= 'z') {
+ c0 = typed->text[0], c1 = typed->text[0] - 'a' + 'A';
+ } else {
+ return 0;
+ }
+
+ UIElement *row = element->children->children;
+ UIElement *target = NULL;
+ bool duplicate = false;
+
+ while (row) {
+ UIElement *item = row->children;
+
+ while (item) {
+ if (item->messageClass == _UIButtonMessage) {
+ UIButton *button = (UIButton *) item;
+
+ if (button->label && button->labelBytes && (button->label[0] == c0 || button->label[0] == c1)) {
+ if (!target) {
+ target = &button->e;
+ } else {
+ duplicate = true;
+ }
+ }
+ }
+
+ item = item->next;
+ }
+
+ row = row->next;
+ }
+
+ if (target) {
+ if (duplicate) {
+ UIElementFocus(target);
+ } else {
+ UIElementMessage(target, UI_MSG_CLICKED, 0, 0);
+ }
+
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+void _UIDialogButtonInvoke(void *cp) {
+ ui.dialogResult = (const char *) cp;
+}
+
+int _UIDialogTextboxMessage(UIElement *element, UIMessage message, int di, void *dp) {
+ if (message == UI_MSG_VALUE_CHANGED) {
+ UITextbox *textbox = (UITextbox *) element;
+ char **buffer = (char **) element->cp;
+ *buffer = (char *) UI_REALLOC(*buffer, textbox->bytes + 1);
+ (*buffer)[textbox->bytes] = 0;
+
+ for (ptrdiff_t i = 0; i < textbox->bytes; i++) {
+ (*buffer)[i] = textbox->string[i];
+ }
+ }
+
+ return 0;
+}
+
+const char *UIDialogShow(UIWindow *window, uint32_t flags, const char *format, ...) {
+ // TODO Enter and escape.
+
+ // Create the dialog wrapper and panel.
+
+ UI_ASSERT(!window->dialog);
+ window->dialog = UIElementCreate(sizeof(UIElement), &window->e, 0, _UIDialogWrapperMessage, "DialogWrapper");
+ UIPanel *panel = UIPanelCreate(window->dialog, UI_PANEL_MEDIUM_SPACING | UI_PANEL_GRAY | UI_PANEL_EXPAND);
+ panel->border = UI_RECT_1(UI_SIZE_PANE_MEDIUM_BORDER * 2);
+ window->e.children->flags |= UI_ELEMENT_DISABLED;
+
+ // Create the dialog contents.
+
+ va_list arguments;
+ va_start(arguments, format);
+ UIPanel *row = NULL;
+ UIElement *focus = NULL;
+
+ for (int i = 0; format[i]; i++) {
+ if (i == 0 || format[i - 1] == '\n') {
+ row = UIPanelCreate(&panel->e, UI_PANEL_HORIZONTAL);
+ row->gap = UI_SIZE_PANE_SMALL_GAP;
+ }
+
+ if (format[i] == ' ' || format[i] == '\n') {
+ } else if (format[i] == '%') {
+ i++;
+
+ if (format[i] == 'b' /* button */) {
+ const char *label = va_arg(arguments, const char *);
+ UIButton *button = UIButtonCreate(&row->e, 0, label, -1);
+ if (!focus) focus = &button->e;
+ button->invoke = _UIDialogButtonInvoke;
+ button->e.cp = (void *) label;
+ } else if (format[i] == 's' /* label from string */) {
+ const char *label = va_arg(arguments, const char *);
+ UILabelCreate(&row->e, 0, label, -1);
+ } else if (format[i] == 't' /* textbox */) {
+ char **buffer = va_arg(arguments, char **);
+ UITextbox *textbox = UITextboxCreate(&row->e, UI_ELEMENT_H_FILL);
+ if (!focus) focus = &textbox->e;
+ if (*buffer) UITextboxReplace(textbox, *buffer, _UIStringLength(*buffer), false);
+ textbox->e.cp = buffer;
+ textbox->e.messageUser = _UIDialogTextboxMessage;
+ } else if (format[i] == 'f' /* horizontal fill */) {
+ UISpacerCreate(&row->e, UI_ELEMENT_H_FILL, 0, 0);
+ } else if (format[i] == 'l' /* horizontal line */) {
+ UISpacerCreate(&row->e, UI_SPACER_LINE | UI_ELEMENT_H_FILL, 0, 1);
+ } else if (format[i] == 'u' /* user */) {
+ UIDialogUserCallback callback = va_arg(arguments, UIDialogUserCallback);
+ callback(&row->e);
+ }
+ } else {
+ int j = i;
+ while (format[j] && format[j] != '%' && format[j] != '\n') j++;
+ UILabelCreate(&row->e, 0, format + i, j - i);
+ i = j - 1;
+ }
+ }
+
+ va_end(arguments);
+
+ window->dialogOldFocus = window->focused;
+ UIElementFocus(focus ? focus : window->dialog);
+
+ // Run the modal message loop.
+
+ int result;
+ ui.dialogResult = NULL;
+ for (int i = 1; i <= 3; i++) _UIWindowSetPressed(window, NULL, i);
+ UIElementRefresh(&window->e);
+ _UIUpdate();
+ while (!ui.dialogResult && _UIMessageLoopSingle(&result));
+ ui.quit = !ui.dialogResult;
+
+ // Destroy the dialog.
+
+ window->e.children->flags &= ~UI_ELEMENT_DISABLED;
+ UIElementDestroy(window->dialog);
+ window->dialog = NULL;
+ UIElementRefresh(&window->e);
+ if (window->dialogOldFocus) UIElementFocus(window->dialogOldFocus);
+ return ui.dialogResult ? ui.dialogResult : "";
+}
+
+bool _UIMenusClose() {
+ UIWindow *window = ui.windows;
+ bool anyClosed = false;
+
+ while (window) {
+ if (window->e.flags & UI_WINDOW_MENU) {
+ UIElementDestroy(&window->e);
+ anyClosed = true;
+ }
+
+ window = window->next;
+ }
+
+ return anyClosed;
+}
+
+#ifndef UI_ESSENCE
+int _UIMenuItemMessage(UIElement *element, UIMessage message, int di, void *dp) {
+ if (message == UI_MSG_CLICKED) {
+ _UIMenusClose();
+ }
+
+ return 0;
+}
+
+int _UIMenuMessage(UIElement *element, UIMessage message, int di, void *dp) {
+ UIMenu *menu = (UIMenu *) element;
+
+ if (message == UI_MSG_GET_WIDTH) {
+ UIElement *child = element->children;
+ int width = 0;
+
+ while (child) {
+ if (~child->flags & UI_ELEMENT_NON_CLIENT) {
+ int w = UIElementMessage(child, UI_MSG_GET_WIDTH, 0, 0);
+ if (w > width) width = w;
+ }
+
+ child = child->next;
+ }
+
+ return width + 4 + UI_SIZE_SCROLL_BAR;
+ } else if (message == UI_MSG_GET_HEIGHT) {
+ UIElement *child = element->children;
+ int height = 0;
+
+ while (child) {
+ if (~child->flags & UI_ELEMENT_NON_CLIENT) {
+ height += UIElementMessage(child, UI_MSG_GET_HEIGHT, 0, 0);
+ }
+
+ child = child->next;
+ }
+
+ return height + 4;
+ } else if (message == UI_MSG_PAINT) {
+ UIDrawBlock((UIPainter *) dp, element->bounds, ui.theme.border);
+ } else if (message == UI_MSG_LAYOUT) {
+ UIElement *child = element->children;
+ int position = element->bounds.t + 2 - menu->vScroll->position;
+ int totalHeight = 0;
+ int scrollBarSize = (menu->e.flags & UI_MENU_NO_SCROLL) ? 0 : UI_SIZE_SCROLL_BAR;
+
+ while (child) {
+ if (~child->flags & UI_ELEMENT_NON_CLIENT) {
+ int height = UIElementMessage(child, UI_MSG_GET_HEIGHT, 0, 0);
+ UIElementMove(child, UI_RECT_4(element->bounds.l + 2, element->bounds.r - scrollBarSize - 2,
+ position, position + height), false);
+ position += height;
+ totalHeight += height;
+ }
+
+ child = child->next;
+ }
+
+ UIRectangle scrollBarBounds = element->bounds;
+ scrollBarBounds.l = scrollBarBounds.r - scrollBarSize * element->window->scale;
+ menu->vScroll->maximum = totalHeight;
+ menu->vScroll->page = UI_RECT_HEIGHT(element->bounds);
+ UIElementMove(&menu->vScroll->e, scrollBarBounds, true);
+ } else if (message == UI_MSG_KEY_TYPED) {
+ UIKeyTyped *m = (UIKeyTyped *) dp;
+
+ if (m->code == UI_KEYCODE_ESCAPE) {
+ _UIMenusClose();
+ return 1;
+ }
+ } else if (message == UI_MSG_MOUSE_WHEEL) {
+ return UIElementMessage(&menu->vScroll->e, message, di, dp);
+ } else if (message == UI_MSG_SCROLLED) {
+ UIElementRefresh(element);
+ }
+
+ return 0;
+}
+
+void UIMenuAddItem(UIMenu *menu, uint32_t flags, const char *label, ptrdiff_t labelBytes, void (*invoke)(void *cp), void *cp) {
+ UIButton *button = UIButtonCreate(&menu->e, flags | UI_BUTTON_MENU_ITEM, label, labelBytes);
+ button->invoke = invoke;
+ button->e.messageUser = _UIMenuItemMessage;
+ button->e.cp = cp;
+}
+
+void _UIMenuPrepare(UIMenu *menu, int *width, int *height) {
+ *width = UIElementMessage(&menu->e, UI_MSG_GET_WIDTH, 0, 0);
+ *height = UIElementMessage(&menu->e, UI_MSG_GET_HEIGHT, 0, 0);
+
+ if (menu->e.flags & UI_MENU_PLACE_ABOVE) {
+ menu->pointY -= *height;
+ }
+}
+
+UIMenu *UIMenuCreate(UIElement *parent, uint32_t flags) {
+ UIWindow *window = UIWindowCreate(parent->window, UI_WINDOW_MENU, 0, 0, 0);
+ UIMenu *menu = (UIMenu *) UIElementCreate(sizeof(UIMenu), &window->e, flags, _UIMenuMessage, "Menu");
+ menu->vScroll = UIScrollBarCreate(&menu->e, UI_ELEMENT_NON_CLIENT);
+
+ if (parent->parent) {
+ UIRectangle screenBounds = UIElementScreenBounds(parent);
+ menu->pointX = screenBounds.l;
+ menu->pointY = (flags & UI_MENU_PLACE_ABOVE) ? (screenBounds.t + 1) : (screenBounds.b - 1);
+ } else {
+ int x = 0, y = 0;
+ _UIWindowGetScreenPosition(parent->window, &x, &y);
+
+ menu->pointX = parent->window->cursorX + x;
+ menu->pointY = parent->window->cursorY + y;
+ }
+
+ return menu;
+}
+#endif
+
+UIRectangle UIElementScreenBounds(UIElement *element) {
+ int x = 0, y = 0;
+ _UIWindowGetScreenPosition(element->window, &x, &y);
+ return UIRectangleAdd(element->bounds, UI_RECT_2(x, y));
+}
+
+void UIWindowRegisterShortcut(UIWindow *window, UIShortcut shortcut) {
+ if (window->shortcutCount + 1 > window->shortcutAllocated) {
+ window->shortcutAllocated = (window->shortcutCount + 1) * 2;
+ window->shortcuts = (UIShortcut *) UI_REALLOC(window->shortcuts, window->shortcutAllocated * sizeof(UIShortcut));
+ }
+
+ window->shortcuts[window->shortcutCount++] = shortcut;
+}
+
+void _UIElementPaint(UIElement *element, UIPainter *painter) {
+ if (element->flags & UI_ELEMENT_HIDE) {
+ return;
+ }
+
+ // Clip painting to the element's clip.
+
+ painter->clip = UIRectangleIntersection(element->clip, painter->clip);
+
+ if (!UI_RECT_VALID(painter->clip)) {
+ return;
+ }
+
+ // Paint the element.
+
+ UIElementMessage(element, UI_MSG_PAINT, 0, painter);
+
+ // Paint its children.
+
+ UIElement *child = element->children;
+ UIRectangle previousClip = painter->clip;
+
+ while (child) {
+ painter->clip = previousClip;
+ _UIElementPaint(child, painter);
+ child = child->next;
+ }
+}
+
+void UIElementFocus(UIElement *element) {
+ UIElement *previous = element->window->focused;
+ if (previous == element) return;
+ element->window->focused = element;
+ if (previous) UIElementMessage(previous, UI_MSG_UPDATE, UI_UPDATE_FOCUSED, 0);
+ if (element) UIElementMessage(element, UI_MSG_UPDATE, UI_UPDATE_FOCUSED, 0);
+
+#ifdef UI_DEBUG
+ _UIInspectorRefresh();
+#endif
+}
+
+void _UIWindowSetPressed(UIWindow *window, UIElement *element, int button) {
+ UIElement *previous = window->pressed;
+ window->pressed = element;
+ window->pressedButton = button;
+ if (previous) UIElementMessage(previous, UI_MSG_UPDATE, UI_UPDATE_PRESSED, 0);
+ if (element) UIElementMessage(element, UI_MSG_UPDATE, UI_UPDATE_PRESSED, 0);
+
+ UIElement *ancestor = element;
+ UIElement *child = NULL;
+
+ while (ancestor) {
+ UIElementMessage(ancestor, UI_MSG_PRESSED_DESCENDENT, 0, child);
+ child = ancestor;
+ ancestor = ancestor->parent;
+ }
+}
+
+bool _UIDestroy(UIElement *element) {
+ if (element->flags & UI_ELEMENT_DESTROY_DESCENDENT) {
+ element->flags &= ~UI_ELEMENT_DESTROY_DESCENDENT;
+
+ UIElement *child = element->children;
+ UIElement **link = &element->children;
+
+ while (child) {
+ UIElement *next = child->next;
+
+ if (_UIDestroy(child)) {
+ *link = next;
+ } else {
+ link = &child->next;
+ }
+
+ child = next;
+ }
+ }
+
+ if (element->flags & UI_ELEMENT_DESTROY) {
+ UIElementMessage(element, UI_MSG_DESTROY, 0, 0);
+
+ if (element->window->pressed == element) {
+ _UIWindowSetPressed(element->window, NULL, 0);
+ }
+
+ if (element->window->hovered == element) {
+ element->window->hovered = &element->window->e;
+ }
+
+ if (element->window->focused == element) {
+ element->window->focused = NULL;
+ }
+
+ if (element->window->dialogOldFocus == element) {
+ element->window->dialogOldFocus = NULL;
+ }
+
+ if (ui.animating == element) {
+ ui.animating = NULL;
+ }
+
+ UI_FREE(element);
+ return true;
+ } else {
+ return false;
+ }
+}
+
+void _UIUpdate() {
+ UIWindow *window = ui.windows;
+ UIWindow **link = &ui.windows;
+
+ while (window) {
+ UIWindow *next = window->next;
+
+ if (_UIDestroy(&window->e)) {
+ *link = next;
+ } else {
+ link = &window->next;
+
+ if (UI_RECT_VALID(window->updateRegion)) {
+#ifdef __cplusplus
+ UIPainter painter = {};
+#else
+ UIPainter painter = { 0 };
+#endif
+ painter.bits = window->bits;
+ painter.width = window->width;
+ painter.height = window->height;
+ painter.clip = UIRectangleIntersection(UI_RECT_2S(window->width, window->height), window->updateRegion);
+ _UIElementPaint(&window->e, &painter);
+ _UIWindowEndPaint(window, &painter);
+ window->updateRegion = UI_RECT_1(0);
+
+#ifdef UI_DEBUG
+ window->lastFullFillCount = (float) painter.fillCount / (UI_RECT_WIDTH(window->updateRegion) * UI_RECT_HEIGHT(window->updateRegion));
+#endif
+ }
+ }
+
+ window = next;
+ }
+}
+
+UIElement *UIElementFindByPoint(UIElement *element, int x, int y) {
+ UIFindByPoint m = { 0 };
+ m.x = x, m.y = y;
+
+ if (UIElementMessage(element, UI_MSG_FIND_BY_POINT, 0, &m)) {
+ return m.result ? m.result : element;
+ }
+
+ UIElement *child = element->children;
+
+ while (child) {
+ if ((~child->flags & UI_ELEMENT_HIDE) && UIRectangleContains(child->clip, x, y)) {
+ return UIElementFindByPoint(child, x, y);
+ }
+
+ child = child->next;
+ }
+
+ return element;
+}
+
+void _UIProcessAnimations() {
+ if (ui.animating) {
+ UIElementMessage(ui.animating, UI_MSG_ANIMATE, 0, 0);
+ _UIUpdate();
+ }
+}
+
+bool _UIMenusOpen() {
+ UIWindow *window = ui.windows;
+
+ while (window) {
+ if (window->e.flags & UI_WINDOW_MENU) {
+ return true;
+ }
+
+ window = window->next;
+ }
+
+ return false;
+}
+
+void _UIWindowDestroyCommon(UIWindow *window) {
+ UI_FREE(window->bits);
+ UI_FREE(window->shortcuts);
+}
+
+UIElement *_UIElementLastChild(UIElement *element) {
+ if (!element->children) {
+ return NULL;
+ }
+
+ UIElement *child = element->children;
+
+ while (child->next) {
+ child = child->next;
+ }
+
+ return child;
+}
+
+UIElement *_UIElementPreviousSibling(UIElement *element) {
+ if (!element->parent) {
+ return NULL;
+ }
+
+ UIElement *sibling = element->parent->children;
+
+ if (sibling == element) {
+ return NULL;
+ }
+
+ while (sibling->next != element) {
+ sibling = sibling->next;
+ UI_ASSERT(sibling);
+ }
+
+ return sibling;
+}
+
+bool _UIWindowInputEvent(UIWindow *window, UIMessage message, int di, void *dp) {
+ bool handled = true;
+
+ if (window->pressed) {
+ if (message == UI_MSG_MOUSE_MOVE) {
+ UIElementMessage(window->pressed, UI_MSG_MOUSE_DRAG, di, dp);
+ } else if (message == UI_MSG_LEFT_UP && window->pressedButton == 1) {
+ if (window->hovered == window->pressed) {
+ UIElementMessage(window->pressed, UI_MSG_CLICKED, di, dp);
+ if (ui.quit || ui.dialogResult) goto end;
+ }
+
+ if (window->pressed) {
+ UIElementMessage(window->pressed, UI_MSG_LEFT_UP, di, dp);
+ if (ui.quit || ui.dialogResult) goto end;
+ _UIWindowSetPressed(window, NULL, 1);
+ }
+ } else if (message == UI_MSG_MIDDLE_UP && window->pressedButton == 2) {
+ UIElementMessage(window->pressed, UI_MSG_MIDDLE_UP, di, dp);
+ if (ui.quit || ui.dialogResult) goto end;
+ _UIWindowSetPressed(window, NULL, 2);
+ } else if (message == UI_MSG_RIGHT_UP && window->pressedButton == 3) {
+ UIElementMessage(window->pressed, UI_MSG_RIGHT_UP, di, dp);
+ if (ui.quit || ui.dialogResult) goto end;
+ _UIWindowSetPressed(window, NULL, 3);
+ }
+ }
+
+ if (window->pressed) {
+ bool inside = UIRectangleContains(window->pressed->clip, window->cursorX, window->cursorY);
+
+ if (inside && window->hovered == &window->e) {
+ window->hovered = window->pressed;
+ UIElementMessage(window->pressed, UI_MSG_UPDATE, UI_UPDATE_HOVERED, 0);
+ } else if (!inside && window->hovered == window->pressed) {
+ window->hovered = &window->e;
+ UIElementMessage(window->pressed, UI_MSG_UPDATE, UI_UPDATE_HOVERED, 0);
+ }
+
+ if (ui.quit || ui.dialogResult) goto end;
+ }
+
+ if (!window->pressed) {
+ UIElement *hovered = UIElementFindByPoint(&window->e, window->cursorX, window->cursorY);
+
+ if (message == UI_MSG_MOUSE_MOVE) {
+ UIElementMessage(hovered, UI_MSG_MOUSE_MOVE, di, dp);
+
+ int cursor = UIElementMessage(window->hovered, UI_MSG_GET_CURSOR, di, dp);
+
+ if (cursor != window->cursorStyle) {
+ window->cursorStyle = cursor;
+ _UIWindowSetCursor(window, cursor);
+ }
+ } else if (message == UI_MSG_LEFT_DOWN) {
+ if ((window->e.flags & UI_WINDOW_MENU) || !_UIMenusClose()) {
+ _UIWindowSetPressed(window, hovered, 1);
+ UIElementMessage(hovered, UI_MSG_LEFT_DOWN, di, dp);
+ }
+ } else if (message == UI_MSG_MIDDLE_DOWN) {
+ if ((window->e.flags & UI_WINDOW_MENU) || !_UIMenusClose()) {
+ _UIWindowSetPressed(window, hovered, 2);
+ UIElementMessage(hovered, UI_MSG_MIDDLE_DOWN, di, dp);
+ }
+ } else if (message == UI_MSG_RIGHT_DOWN) {
+ if ((window->e.flags & UI_WINDOW_MENU) || !_UIMenusClose()) {
+ _UIWindowSetPressed(window, hovered, 3);
+ UIElementMessage(hovered, UI_MSG_RIGHT_DOWN, di, dp);
+ }
+ } else if (message == UI_MSG_MOUSE_WHEEL) {
+ UIElement *element = hovered;
+
+ while (element) {
+ if (UIElementMessage(element, UI_MSG_MOUSE_WHEEL, di, dp)) {
+ break;
+ }
+
+ element = element->parent;
+ }
+ } else if (message == UI_MSG_KEY_TYPED) {
+ handled = false;
+
+ if (window->focused) {
+ UIElement *element = window->focused;
+
+ while (element) {
+ if (UIElementMessage(element, UI_MSG_KEY_TYPED, di, dp)) {
+ handled = true;
+ break;
+ }
+
+ element = element->parent;
+ }
+ } else {
+ if (UIElementMessage(&window->e, UI_MSG_KEY_TYPED, di, dp)) {
+ handled = true;
+ }
+ }
+
+ if (!handled && !_UIMenusOpen()) {
+ UIKeyTyped *m = (UIKeyTyped *) dp;
+
+ if (m->code == UI_KEYCODE_TAB && !window->ctrl && !window->alt) {
+ UIElement *start = window->focused ? window->focused : &window->e;
+ UIElement *element = start;
+
+ do {
+ if (element->children && !(element->flags & (UI_ELEMENT_HIDE | UI_ELEMENT_DISABLED))) {
+ element = window->shift ? _UIElementLastChild(element) : element->children;
+ continue;
+ }
+
+ while (element) {
+ if (window->shift ? (element->parent && element->parent->children != element) : !!element->next) {
+ element = window->shift ? _UIElementPreviousSibling(element) : element->next;
+ break;
+ } else {
+ element = element->parent;
+ }
+ }
+
+ if (!element) {
+ element = &window->e;
+ }
+ } while (element != start && ((~element->flags & UI_ELEMENT_TAB_STOP)
+ || (element->flags & (UI_ELEMENT_HIDE | UI_ELEMENT_DISABLED))));
+
+ if (~element->flags & UI_ELEMENT_WINDOW) {
+ UIElementFocus(element);
+ }
+
+ handled = true;
+ } else if (!window->dialog) {
+ for (intptr_t i = window->shortcutCount - 1; i >= 0; i--) {
+ UIShortcut *shortcut = window->shortcuts + i;
+
+ if (shortcut->code == m->code && shortcut->ctrl == window->ctrl
+ && shortcut->shift == window->shift && shortcut->alt == window->alt) {
+ shortcut->invoke(shortcut->cp);
+ handled = true;
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ if (ui.quit || ui.dialogResult) goto end;
+
+ if (hovered != window->hovered) {
+ UIElement *previous = window->hovered;
+ window->hovered = hovered;
+ UIElementMessage(previous, UI_MSG_UPDATE, UI_UPDATE_HOVERED, 0);
+ UIElementMessage(window->hovered, UI_MSG_UPDATE, UI_UPDATE_HOVERED, 0);
+ }
+ }
+
+ end: _UIUpdate();
+ return handled;
+}
+
+UIFont *UIFontCreate(const char *cPath, uint32_t size) {
+ UIFont *font = (UIFont *) UI_CALLOC(sizeof(UIFont));
+
+#ifdef UI_FREETYPE
+ if (cPath) {
+ if (!FT_New_Face(ui.ft, cPath, 0, &font->font)) {
+ FT_Set_Char_Size(font->font, 0, size * 64, 100, 100);
+ FT_Load_Char(font->font, 'a', FT_LOAD_DEFAULT);
+ font->glyphWidth = font->font->glyph->advance.x / 64;
+ font->glyphHeight = (font->font->size->metrics.ascender - font->font->size->metrics.descender) / 64;
+ font->isFreeType = true;
+ return font;
+ }
+ }
+#endif
+
+ font->glyphWidth = 9;
+ font->glyphHeight = 16;
+ return font;
+}
+
+UIFont *UIFontActivate(UIFont *font) {
+ UIFont *previous = ui.activeFont;
+ ui.activeFont = font;
+ return previous;
+}
+
+void _UIInitialiseCommon() {
+ ui.theme = _uiThemeDark;
+
+#ifdef UI_FREETYPE
+ FT_Init_FreeType(&ui.ft);
+ UIFontActivate(UIFontCreate(_UI_TO_STRING_2(UI_FONT_PATH), 11));
+#else
+ UIFontActivate(UIFontCreate(0, 0));
+#endif
+}
+
+void _UIWindowAdd(UIWindow *window) {
+ window->scale = 1.0f;
+ window->e.window = window;
+ window->hovered = &window->e;
+ window->next = ui.windows;
+ ui.windows = window;
+}
+
+int _UIWindowMessageCommon(UIElement *element, UIMessage message, int di, void *dp) {
+ if (message == UI_MSG_LAYOUT && element->children) {
+ UIElementMove(element->children, element->bounds, false);
+ if (element->window->dialog) UIElementMove(element->window->dialog, element->bounds, false);
+ UIElementRepaint(element, NULL);
+ } else if (message == UI_MSG_FIND_BY_POINT) {
+ UIFindByPoint *m = (UIFindByPoint *) dp;
+ if (element->window->dialog) m->result = UIElementFindByPoint(element->window->dialog, m->x, m->y);
+ else if (!element->children) m->result = NULL;
+ else m->result = UIElementFindByPoint(element->children, m->x, m->y);
+ return 1;
+ }
+
+ return 0;
+}
+
+#ifdef UI_DEBUG
+
+void UIInspectorLog(const char *cFormat, ...) {
+ va_list arguments;
+ va_start(arguments, cFormat);
+ char buffer[4096];
+ vsnprintf(buffer, sizeof(buffer), cFormat, arguments);
+ UICodeInsertContent(ui.inspectorLog, buffer, -1, false);
+ va_end(arguments);
+ UIElementRefresh(&ui.inspectorLog->e);
+}
+
+UIElement *_UIInspectorFindNthElement(UIElement *element, int *index, int *depth) {
+ if (*index == 0) {
+ return element;
+ }
+
+ *index = *index - 1;
+
+ UIElement *child = element->children;
+
+ while (child) {
+ if (!(child->flags & (UI_ELEMENT_DESTROY | UI_ELEMENT_HIDE))) {
+ UIElement *result = _UIInspectorFindNthElement(child, index, depth);
+
+ if (result) {
+ if (depth) {
+ *depth = *depth + 1;
+ }
+
+ return result;
+ }
+ }
+
+ child = child->next;
+ }
+
+ return NULL;
+}
+
+int _UIInspectorTableMessage(UIElement *element, UIMessage message, int di, void *dp) {
+ if (!ui.inspectorTarget) {
+ return 0;
+ }
+
+ if (message == UI_MSG_TABLE_GET_ITEM) {
+ UITableGetItem *m = (UITableGetItem *) dp;
+ int index = m->index;
+ int depth = 0;
+ UIElement *element = _UIInspectorFindNthElement(&ui.inspectorTarget->e, &index, &depth);
+ if (!element) return 0;
+
+ if (m->column == 0) {
+ return snprintf(m->buffer, m->bufferBytes, "%.*s%s", depth * 2, " ", element->cClassName);
+ } else if (m->column == 1) {
+ return snprintf(m->buffer, m->bufferBytes, "%d:%d, %d:%d", UI_RECT_ALL(element->bounds));
+ } else if (m->column == 2) {
+ return snprintf(m->buffer, m->bufferBytes, "%d%c", element->id, element->window->focused == element ? '*' : ' ');
+ }
+ } else if (message == UI_MSG_MOUSE_MOVE) {
+ int index = UITableHitTest(ui.inspectorTable, element->window->cursorX, element->window->cursorY);
+ UIElement *element = NULL;
+ if (index >= 0) element = _UIInspectorFindNthElement(&ui.inspectorTarget->e, &index, NULL);
+ UIWindow *window = ui.inspectorTarget;
+ UIPainter painter = { 0 };
+ window->updateRegion = window->e.bounds;
+ painter.bits = window->bits;
+ painter.width = window->width;
+ painter.height = window->height;
+ painter.clip = UI_RECT_2S(window->width, window->height);
+
+ for (int i = 0; i < window->width * window->height; i++) {
+ window->bits[i] = 0xFF00FF;
+ }
+
+ _UIElementPaint(&window->e, &painter);
+ painter.clip = UI_RECT_2S(window->width, window->height);
+
+ if (element) {
+ UIDrawInvert(&painter, element->bounds);
+ UIDrawInvert(&painter, UIRectangleAdd(element->bounds, UI_RECT_1I(4)));
+ }
+
+ _UIWindowEndPaint(window, &painter);
+ }
+
+ return 0;
+}
+
+void _UIInspectorCreate() {
+ ui.inspector = UIWindowCreate(0, UI_WINDOW_INSPECTOR, "Inspector", 0, 0);
+ UISplitPane *splitPane = UISplitPaneCreate(&ui.inspector->e, 0, 0.5f);
+ ui.inspectorTable = UITableCreate(&splitPane->e, 0, "Class\tBounds\tID");
+ ui.inspectorTable->e.messageUser = _UIInspectorTableMessage;
+ ui.inspectorLog = UICodeCreate(&splitPane->e, 0);
+}
+
+int _UIInspectorCountElements(UIElement *element) {
+ UIElement *child = element->children;
+ int count = 1;
+
+ while (child) {
+ if (!(child->flags & (UI_ELEMENT_DESTROY | UI_ELEMENT_HIDE))) {
+ count += _UIInspectorCountElements(child);
+ }
+
+ child = child->next;
+ }
+
+ return count;
+}
+
+void _UIInspectorRefresh() {
+ if (!ui.inspectorTarget || !ui.inspector || !ui.inspectorTable) return;
+ ui.inspectorTable->itemCount = _UIInspectorCountElements(&ui.inspectorTarget->e);
+ UITableResizeColumns(ui.inspectorTable);
+ UIElementRefresh(&ui.inspectorTable->e);
+}
+
+void _UIInspectorSetFocusedWindow(UIWindow *window) {
+ if (!ui.inspector || !ui.inspectorTable) return;
+
+ if (window->e.flags & UI_WINDOW_INSPECTOR) {
+ return;
+ }
+
+ if (ui.inspectorTarget != window) {
+ ui.inspectorTarget = window;
+ _UIInspectorRefresh();
+ }
+}
+
+#else
+
+void _UIInspectorCreate() {}
+void _UIInspectorSetFocusedWindow(UIWindow *window) {}
+void _UIInspectorRefresh() {}
+
+#endif
+
+#ifdef UI_AUTOMATION_TESTS
+
+int UIAutomationRunTests();
+
+void UIAutomationProcessMessage() {
+ int result;
+ _UIMessageLoopSingle(&result);
+}
+
+void UIAutomationKeyboardTypeSingle(intptr_t code, bool ctrl, bool shift, bool alt) {
+ UIWindow *window = ui.windows; // TODO Get the focused window.
+ UIKeyTyped m = { 0 };
+ m.code = code;
+ window->ctrl = ctrl;
+ window->alt = alt;
+ window->shift = shift;
+ _UIWindowInputEvent(window, UI_MSG_KEY_TYPED, 0, &m);
+ window->ctrl = false;
+ window->alt = false;
+ window->shift = false;
+}
+
+void UIAutomationKeyboardType(const char *string) {
+ UIWindow *window = ui.windows; // TODO Get the focused window.
+
+ UIKeyTyped m = { 0 };
+ char c[2];
+ m.text = c;
+ m.textBytes = 1;
+ c[1] = 0;
+
+ for (int i = 0; string[i]; i++) {
+ window->ctrl = false;
+ window->alt = false;
+ window->shift = (c[0] >= 'A' && c[0] <= 'Z');
+ c[0] = string[i];
+ m.code = (c[0] >= 'A' && c[0] <= 'Z') ? UI_KEYCODE_LETTER(c[0])
+ : c[0] == '\n' ? UI_KEYCODE_ENTER
+ : c[0] == '\t' ? UI_KEYCODE_TAB
+ : c[0] == ' ' ? UI_KEYCODE_SPACE
+ : (c[0] >= '0' && c[0] <= '9') ? UI_KEYCODE_DIGIT(c[0]) : 0;
+ _UIWindowInputEvent(window, UI_MSG_KEY_TYPED, 0, &m);
+ }
+
+ window->ctrl = false;
+ window->alt = false;
+ window->shift = false;
+}
+
+bool UIAutomationCheckCodeLineMatches(UICode *code, int lineIndex, const char *input) {
+ if (lineIndex < 1 || lineIndex > code->lineCount) return false;
+ int bytes = 0;
+ for (int i = 0; input[i]; i++) bytes++;
+ if (bytes != code->lines[lineIndex - 1].bytes) return false;
+ for (int i = 0; input[i]; i++) if (code->content[code->lines[lineIndex - 1].offset + i] != input[i]) return false;
+ return true;
+}
+
+bool UIAutomationCheckTableItemMatches(UITable *table, int row, int column, const char *input) {
+ int bytes = 0;
+ for (int i = 0; input[i]; i++) bytes++;
+ if (row < 0 || row >= table->itemCount) return false;
+ if (column < 0 || column >= table->columnCount) return false;
+ char *buffer = (char *) UI_MALLOC(bytes + 1);
+ UITableGetItem m = { 0 };
+ m.buffer = buffer;
+ m.bufferBytes = bytes + 1;
+ m.column = column;
+ m.index = row;
+ int length = UIElementMessage(&table->e, UI_MSG_TABLE_GET_ITEM, 0, &m);
+ if (length != bytes) return false;
+ for (int i = 0; input[i]; i++) if (buffer[i] != input[i]) return false;
+ return true;
+}
+
+#endif
+
+int UIMessageLoop() {
+ _UIInspectorCreate();
+ _UIUpdate();
+#ifdef UI_AUTOMATION_TESTS
+ return UIAutomationRunTests();
+#else
+ int result = 0;
+ while (!ui.quit && _UIMessageLoopSingle(&result)) ui.dialogResult = NULL;
+ return result;
+#endif
+}
+
+#ifdef UI_LINUX
+
+const int UI_KEYCODE_A = XK_a;
+const int UI_KEYCODE_BACKSPACE = XK_BackSpace;
+const int UI_KEYCODE_DELETE = XK_Delete;
+const int UI_KEYCODE_DOWN = XK_Down;
+const int UI_KEYCODE_END = XK_End;
+const int UI_KEYCODE_ENTER = XK_Return;
+const int UI_KEYCODE_ESCAPE = XK_Escape;
+const int UI_KEYCODE_F1 = XK_F1;
+const int UI_KEYCODE_HOME = XK_Home;
+const int UI_KEYCODE_LEFT = XK_Left;
+const int UI_KEYCODE_RIGHT = XK_Right;
+const int UI_KEYCODE_SPACE = XK_space;
+const int UI_KEYCODE_TAB = XK_Tab;
+const int UI_KEYCODE_UP = XK_Up;
+const int UI_KEYCODE_INSERT = XK_Insert;
+const int UI_KEYCODE_0 = XK_0;
+
+int _UIWindowMessage(UIElement *element, UIMessage message, int di, void *dp) {
+ if (message == UI_MSG_DESTROY) {
+ UIWindow *window = (UIWindow *) element;
+ _UIWindowDestroyCommon(window);
+ window->image->data = NULL;
+ XDestroyImage(window->image);
+ XDestroyIC(window->xic);
+ XDestroyWindow(ui.display, ((UIWindow *) element)->window);
+ }
+
+ return _UIWindowMessageCommon(element, message, di, dp);
+}
+
+UIWindow *UIWindowCreate(UIWindow *owner, uint32_t flags, const char *cTitle, int _width, int _height) {
+ _UIMenusClose();
+
+ UIWindow *window = (UIWindow *) UIElementCreate(sizeof(UIWindow), NULL, flags | UI_ELEMENT_WINDOW, _UIWindowMessage, "Window");
+ _UIWindowAdd(window);
+ if (owner) window->scale = owner->scale;
+
+ int width = (flags & UI_WINDOW_MENU) ? 1 : _width ? _width : 800;
+ int height = (flags & UI_WINDOW_MENU) ? 1 : _height ? _height : 600;
+
+ XSetWindowAttributes attributes = {};
+ attributes.override_redirect = flags & UI_WINDOW_MENU;
+
+ window->window = XCreateWindow(ui.display, DefaultRootWindow(ui.display), 0, 0, width, height, 0, 0,
+ InputOutput, CopyFromParent, CWOverrideRedirect, &attributes);
+ if (cTitle) XStoreName(ui.display, window->window, cTitle);
+ XSelectInput(ui.display, window->window, SubstructureNotifyMask | ExposureMask | PointerMotionMask
+ | ButtonPressMask | ButtonReleaseMask | KeyPressMask | KeyReleaseMask | StructureNotifyMask
+ | EnterWindowMask | LeaveWindowMask | ButtonMotionMask | KeymapStateMask | FocusChangeMask | PropertyChangeMask);
+
+ if (flags & UI_WINDOW_MAXIMIZE) {
+ Atom atoms[2] = { XInternAtom(ui.display, "_NET_WM_STATE_MAXIMIZED_HORZ", 0), XInternAtom(ui.display, "_NET_WM_STATE_MAXIMIZED_VERT", 0) };
+ XChangeProperty(ui.display, window->window, XInternAtom(ui.display, "_NET_WM_STATE", 0), XA_ATOM, 32, PropModeReplace, (unsigned char *) atoms, 2);
+ }
+
+ if (~flags & UI_WINDOW_MENU) {
+ XMapRaised(ui.display, window->window);
+ }
+
+ if (flags & UI_WINDOW_CENTER_IN_OWNER) {
+ int x = 0, y = 0;
+ _UIWindowGetScreenPosition(owner, &x, &y);
+ XMoveResizeWindow(ui.display, window->window, x + owner->width / 2 - width / 2, y + owner->height / 2 - height / 2, width, height);
+ }
+
+ XSetWMProtocols(ui.display, window->window, &ui.windowClosedID, 1);
+ window->image = XCreateImage(ui.display, ui.visual, 24, ZPixmap, 0, NULL, 10, 10, 32, 0);
+
+ window->xic = XCreateIC(ui.xim, XNInputStyle, XIMPreeditNothing | XIMStatusNothing, XNClientWindow, window->window, XNFocusWindow, window->window, NULL);
+
+ int dndVersion = 4;
+ XChangeProperty(ui.display, window->window, ui.dndAwareID, XA_ATOM, 32 /* bits */, PropModeReplace, (uint8_t *) &dndVersion, 1);
+
+ return window;
+}
+
+Display *_UIX11GetDisplay() {
+ return ui.display;
+}
+
+UIWindow *_UIFindWindow(Window window) {
+ UIWindow *w = ui.windows;
+
+ while (w) {
+ if (w->window == window) {
+ return w;
+ }
+
+ w = w->next;
+ }
+
+ return NULL;
+}
+
+void _UIClipboardWriteText(UIWindow *window, char *text) {
+ UI_FREE(ui.pasteText);
+ ui.pasteText = text;
+ XSetSelectionOwner(ui.display, ui.clipboardID, window->window, 0);
+}
+
+char *_UIClipboardReadTextStart(UIWindow *window, size_t *bytes) {
+ Window clipboardOwner = XGetSelectionOwner(ui.display, ui.clipboardID);
+
+ if (clipboardOwner == None) {
+ return NULL;
+ }
+
+ if (_UIFindWindow(clipboardOwner)) {
+ *bytes = strlen(ui.pasteText);
+ char *copy = (char *) UI_MALLOC(*bytes);
+ memcpy(copy, ui.pasteText, *bytes);
+ return copy;
+ }
+
+ XConvertSelection(ui.display, ui.clipboardID, XA_STRING, ui.xSelectionDataID, window->window, CurrentTime);
+ XSync(ui.display, 0);
+ XNextEvent(ui.display, &ui.copyEvent);
+
+ // Hack to get around the fact that PropertyNotify arrives before SelectionNotify.
+ // We need PropertyNotify for incremental transfers.
+ while (ui.copyEvent.type == PropertyNotify) {
+ XNextEvent(ui.display, &ui.copyEvent);
+ }
+
+ if (ui.copyEvent.type == SelectionNotify && ui.copyEvent.xselection.selection == ui.clipboardID && ui.copyEvent.xselection.property) {
+ Atom target;
+ // This `itemAmount` is actually `bytes_after_return`
+ unsigned long size, itemAmount;
+ char *data;
+ int format;
+ XGetWindowProperty(ui.copyEvent.xselection.display, ui.copyEvent.xselection.requestor, ui.copyEvent.xselection.property, 0L, ~0L, 0,
+ AnyPropertyType, &target, &format, &size, &itemAmount, (unsigned char **) &data);
+
+ // We have to allocate for incremental transfers but we don't have to allocate for non-incremental transfers.
+ // I'm allocating for both here to make _UIClipboardReadTextEnd work the same for both
+ if (target != ui.incrID) {
+ *bytes = size;
+ char *copy = (char *) UI_MALLOC(*bytes);
+ memcpy(copy, data, *bytes);
+ XFree(data);
+ XDeleteProperty(ui.copyEvent.xselection.display, ui.copyEvent.xselection.requestor, ui.copyEvent.xselection.property);
+ return copy;
+ }
+
+ XFree(data);
+ XDeleteProperty(ui.display, ui.copyEvent.xselection.requestor, ui.copyEvent.xselection.property);
+ XSync(ui.display, 0);
+
+ *bytes = 0;
+ char *fullData = NULL;
+
+ while (true) {
+ // TODO Timeout.
+ XNextEvent(ui.display, &ui.copyEvent);
+
+ if (ui.copyEvent.type == PropertyNotify) {
+ // The other case - PropertyDelete would be caused by us and can be ignored
+ if (ui.copyEvent.xproperty.state == PropertyNewValue) {
+ unsigned long chunkSize;
+
+ // Note that this call deletes the property.
+ XGetWindowProperty(ui.display, ui.copyEvent.xproperty.window, ui.copyEvent.xproperty.atom, 0L, ~0L,
+ True, AnyPropertyType, &target, &format, &chunkSize, &itemAmount, (unsigned char **) &data);
+
+ if (chunkSize == 0) {
+ return fullData;
+ } else {
+ ptrdiff_t currentOffset = *bytes;
+ *bytes += chunkSize;
+ fullData = (char *) UI_REALLOC(fullData, *bytes);
+ memcpy(fullData + currentOffset, data, chunkSize);
+ }
+
+ XFree(data);
+ }
+ }
+ }
+ } else {
+ // TODO What should happen in this case? Is the next event always going to be the selection event?
+ return NULL;
+ }
+}
+
+void _UIClipboardReadTextEnd(UIWindow *window, char *text) {
+ if (text) {
+ //XFree(text);
+ //XDeleteProperty(ui.copyEvent.xselection.display, ui.copyEvent.xselection.requestor, ui.copyEvent.xselection.property);
+ UI_FREE(text);
+ }
+}
+
+void UIInitialise() {
+ _UIInitialiseCommon();
+
+ XInitThreads();
+
+ ui.display = XOpenDisplay(NULL);
+ ui.visual = XDefaultVisual(ui.display, 0);
+
+ ui.windowClosedID = XInternAtom(ui.display, "WM_DELETE_WINDOW", 0);
+ ui.primaryID = XInternAtom(ui.display, "PRIMARY", 0);
+ ui.dndEnterID = XInternAtom(ui.display, "XdndEnter", 0);
+ ui.dndPositionID = XInternAtom(ui.display, "XdndPosition", 0);
+ ui.dndStatusID = XInternAtom(ui.display, "XdndStatus", 0);
+ ui.dndActionCopyID = XInternAtom(ui.display, "XdndActionCopy", 0);
+ ui.dndDropID = XInternAtom(ui.display, "XdndDrop", 0);
+ ui.dndSelectionID = XInternAtom(ui.display, "XdndSelection", 0);
+ ui.dndFinishedID = XInternAtom(ui.display, "XdndFinished", 0);
+ ui.dndAwareID = XInternAtom(ui.display, "XdndAware", 0);
+ ui.uriListID = XInternAtom(ui.display, "text/uri-list", 0);
+ ui.plainTextID = XInternAtom(ui.display, "text/plain", 0);
+ ui.clipboardID = XInternAtom(ui.display, "CLIPBOARD", 0);
+ ui.xSelectionDataID = XInternAtom(ui.display, "XSEL_DATA", 0);
+ ui.textID = XInternAtom(ui.display, "TEXT", 0);
+ ui.targetID = XInternAtom(ui.display, "TARGETS", 0);
+ ui.incrID = XInternAtom(ui.display, "INCR", 0);
+
+ ui.cursors[UI_CURSOR_ARROW] = XCreateFontCursor(ui.display, XC_left_ptr);
+ ui.cursors[UI_CURSOR_TEXT] = XCreateFontCursor(ui.display, XC_xterm);
+ ui.cursors[UI_CURSOR_SPLIT_V] = XCreateFontCursor(ui.display, XC_sb_v_double_arrow);
+ ui.cursors[UI_CURSOR_SPLIT_H] = XCreateFontCursor(ui.display, XC_sb_h_double_arrow);
+ ui.cursors[UI_CURSOR_FLIPPED_ARROW] = XCreateFontCursor(ui.display, XC_right_ptr);
+ ui.cursors[UI_CURSOR_CROSS_HAIR] = XCreateFontCursor(ui.display, XC_crosshair);
+ ui.cursors[UI_CURSOR_HAND] = XCreateFontCursor(ui.display, XC_hand1);
+ ui.cursors[UI_CURSOR_RESIZE_UP] = XCreateFontCursor(ui.display, XC_top_side);
+ ui.cursors[UI_CURSOR_RESIZE_LEFT] = XCreateFontCursor(ui.display, XC_left_side);
+ ui.cursors[UI_CURSOR_RESIZE_UP_RIGHT] = XCreateFontCursor(ui.display, XC_top_right_corner);
+ ui.cursors[UI_CURSOR_RESIZE_UP_LEFT] = XCreateFontCursor(ui.display, XC_top_left_corner);
+ ui.cursors[UI_CURSOR_RESIZE_DOWN] = XCreateFontCursor(ui.display, XC_bottom_side);
+ ui.cursors[UI_CURSOR_RESIZE_RIGHT] = XCreateFontCursor(ui.display, XC_right_side);
+ ui.cursors[UI_CURSOR_RESIZE_DOWN_LEFT] = XCreateFontCursor(ui.display, XC_bottom_left_corner);
+ ui.cursors[UI_CURSOR_RESIZE_DOWN_RIGHT] = XCreateFontCursor(ui.display, XC_bottom_right_corner);
+
+ XSetLocaleModifiers("");
+
+ ui.xim = XOpenIM(ui.display, 0, 0, 0);
+
+ if(!ui.xim){
+ XSetLocaleModifiers("@im=none");
+ ui.xim = XOpenIM(ui.display, 0, 0, 0);
+ }
+}
+
+void _UIWindowSetCursor(UIWindow *window, int cursor) {
+ XDefineCursor(ui.display, window->window, ui.cursors[cursor]);
+}
+
+void _UIX11ResetCursor(UIWindow *window) {
+ XDefineCursor(ui.display, window->window, ui.cursors[UI_CURSOR_ARROW]);
+}
+
+void _UIWindowEndPaint(UIWindow *window, UIPainter *painter) {
+ (void) painter;
+
+ XPutImage(ui.display, window->window, DefaultGC(ui.display, 0), window->image,
+ UI_RECT_TOP_LEFT(window->updateRegion), UI_RECT_TOP_LEFT(window->updateRegion),
+ UI_RECT_SIZE(window->updateRegion));
+}
+
+void _UIWindowGetScreenPosition(UIWindow *window, int *_x, int *_y) {
+ Window child;
+ XTranslateCoordinates(ui.display, window->window, DefaultRootWindow(ui.display), 0, 0, _x, _y, &child);
+}
+
+void UIMenuShow(UIMenu *menu) {
+ int width, height;
+ _UIMenuPrepare(menu, &width, &height);
+
+ for (int i = 0; i < ScreenCount(ui.display); i++) {
+ Screen *screen = ScreenOfDisplay(ui.display, i);
+
+ int x, y;
+ Window child;
+ XTranslateCoordinates(ui.display, screen->root, DefaultRootWindow(ui.display), 0, 0, &x, &y, &child);
+
+ if (menu->pointX >= x && menu->pointX < x + screen->width
+ && menu->pointY >= y && menu->pointY < y + screen->height) {
+ if (menu->pointX + width > x + screen->width) menu->pointX = x + screen->width - width;
+ if (menu->pointY + height > y + screen->height) menu->pointY = y + screen->height - height;
+ if (menu->pointX < x) menu->pointX = x;
+ if (menu->pointY < y) menu->pointY = y;
+ if (menu->pointX + width > x + screen->width) width = x + screen->width - menu->pointX;
+ if (menu->pointY + height > y + screen->height) height = y + screen->height - menu->pointY;
+ break;
+ }
+ }
+
+ Atom properties[] = {
+ XInternAtom(ui.display, "_NET_WM_WINDOW_TYPE", true),
+ XInternAtom(ui.display, "_NET_WM_WINDOW_TYPE_DROPDOWN_MENU", true),
+ XInternAtom(ui.display, "_MOTIF_WM_HINTS", true),
+ };
+
+ XChangeProperty(ui.display, menu->e.window->window, properties[0], XA_ATOM, 32, PropModeReplace, (uint8_t *) properties, 2);
+ XSetTransientForHint(ui.display, menu->e.window->window, DefaultRootWindow(ui.display));
+
+ struct Hints {
+ int flags;
+ int functions;
+ int decorations;
+ int inputMode;
+ int status;
+ };
+
+ struct Hints hints = { 0 };
+ hints.flags = 2;
+ XChangeProperty(ui.display, menu->e.window->window, properties[2], properties[2], 32, PropModeReplace, (uint8_t *) &hints, 5);
+
+ XMapWindow(ui.display, menu->e.window->window);
+ XMoveResizeWindow(ui.display, menu->e.window->window, menu->pointX, menu->pointY, width, height);
+}
+
+void UIWindowPack(UIWindow *window, int _width) {
+ int width = _width ? _width : UIElementMessage(window->e.children, UI_MSG_GET_WIDTH, 0, 0);
+ int height = UIElementMessage(window->e.children, UI_MSG_GET_HEIGHT, width, 0);
+ XResizeWindow(ui.display, window->window, width, height);
+}
+
+bool _UIProcessEvent(XEvent *event) {
+ if (event->type == ClientMessage && (Atom) event->xclient.data.l[0] == ui.windowClosedID) {
+ UIWindow *window = _UIFindWindow(event->xclient.window);
+ if (!window) return false;
+ bool exit = !UIElementMessage(&window->e, UI_MSG_WINDOW_CLOSE, 0, 0);
+ if (exit) return true;
+ _UIUpdate();
+ return false;
+ } else if (event->type == Expose) {
+ UIWindow *window = _UIFindWindow(event->xexpose.window);
+ if (!window) return false;
+ XPutImage(ui.display, window->window, DefaultGC(ui.display, 0), window->image, 0, 0, 0, 0, window->width, window->height);
+ } else if (event->type == ConfigureNotify) {
+ UIWindow *window = _UIFindWindow(event->xconfigure.window);
+ if (!window) return false;
+
+ if (window->width != event->xconfigure.width || window->height != event->xconfigure.height) {
+ window->width = event->xconfigure.width;
+ window->height = event->xconfigure.height;
+ window->bits = (uint32_t *) UI_REALLOC(window->bits, window->width * window->height * 4);
+ window->image->width = window->width;
+ window->image->height = window->height;
+ window->image->bytes_per_line = window->width * 4;
+ window->image->data = (char *) window->bits;
+ window->e.bounds = UI_RECT_2S(window->width, window->height);
+ window->e.clip = UI_RECT_2S(window->width, window->height);
+#ifdef UI_DEBUG
+ for (int i = 0; i < window->width * window->height; i++) window->bits[i] = 0xFF00FF;
+#endif
+ UIElementMessage(&window->e, UI_MSG_LAYOUT, 0, 0);
+ _UIUpdate();
+ }
+ } else if (event->type == MotionNotify) {
+ UIWindow *window = _UIFindWindow(event->xmotion.window);
+ if (!window) return false;
+ window->cursorX = event->xmotion.x;
+ window->cursorY = event->xmotion.y;
+ _UIWindowInputEvent(window, UI_MSG_MOUSE_MOVE, 0, 0);
+ } else if (event->type == LeaveNotify) {
+ UIWindow *window = _UIFindWindow(event->xcrossing.window);
+ if (!window) return false;
+
+ if (!window->pressed) {
+ window->cursorX = -1;
+ window->cursorY = -1;
+ }
+
+ _UIWindowInputEvent(window, UI_MSG_MOUSE_MOVE, 0, 0);
+ } else if (event->type == ButtonPress || event->type == ButtonRelease) {
+ UIWindow *window = _UIFindWindow(event->xbutton.window);
+ if (!window) return false;
+ window->cursorX = event->xbutton.x;
+ window->cursorY = event->xbutton.y;
+
+ if (event->xbutton.button >= 1 && event->xbutton.button <= 3) {
+ _UIWindowInputEvent(window, (UIMessage) ((event->type == ButtonPress ? UI_MSG_LEFT_DOWN : UI_MSG_LEFT_UP)
+ + event->xbutton.button * 2 - 2), 0, 0);
+ } else if (event->xbutton.button == 4) {
+ _UIWindowInputEvent(window, UI_MSG_MOUSE_WHEEL, -72, 0);
+ } else if (event->xbutton.button == 5) {
+ _UIWindowInputEvent(window, UI_MSG_MOUSE_WHEEL, 72, 0);
+ }
+
+ _UIInspectorSetFocusedWindow(window);
+ } else if (event->type == KeyPress) {
+ UIWindow *window = _UIFindWindow(event->xkey.window);
+ if (!window) return false;
+
+ if (event->xkey.x == 0x7123 && event->xkey.y == 0x7456) {
+ // HACK! See UIWindowPostMessage.
+ UIElementMessage(&window->e, (UIMessage) event->xkey.state, 0,
+ (void *) (((uintptr_t) (event->xkey.time & 0xFFFFFFFF) << 32)
+ | ((uintptr_t) (event->xkey.x_root & 0xFFFF) << 0)
+ | ((uintptr_t) (event->xkey.y_root & 0xFFFF) << 16)));
+ _UIUpdate();
+ } else {
+ char text[32];
+ KeySym symbol = NoSymbol;
+ Status status;
+ // printf("%ld, %s\n", symbol, text);
+ UIKeyTyped m = { 0 };
+ m.textBytes = Xutf8LookupString(window->xic, &event->xkey, text, sizeof(text) - 1, &symbol, &status);
+ m.text = text;
+ m.code = XLookupKeysym(&event->xkey, 0);
+
+ if (symbol == XK_Control_L || symbol == XK_Control_R) {
+ window->ctrl = true;
+ window->ctrlCode = event->xkey.keycode;
+ _UIWindowInputEvent(window, UI_MSG_MOUSE_MOVE, 0, 0);
+ } else if (symbol == XK_Shift_L || symbol == XK_Shift_R) {
+ window->shift = true;
+ window->shiftCode = event->xkey.keycode;
+ _UIWindowInputEvent(window, UI_MSG_MOUSE_MOVE, 0, 0);
+ } else if (symbol == XK_Alt_L || symbol == XK_Alt_R) {
+ window->alt = true;
+ window->altCode = event->xkey.keycode;
+ _UIWindowInputEvent(window, UI_MSG_MOUSE_MOVE, 0, 0);
+ } else if (symbol == XK_KP_Left) {
+ m.code = UI_KEYCODE_LEFT;
+ } else if (symbol == XK_KP_Right) {
+ m.code = UI_KEYCODE_RIGHT;
+ } else if (symbol == XK_KP_Up) {
+ m.code = UI_KEYCODE_UP;
+ } else if (symbol == XK_KP_Down) {
+ m.code = UI_KEYCODE_DOWN;
+ } else if (symbol == XK_KP_Home) {
+ m.code = UI_KEYCODE_HOME;
+ } else if (symbol == XK_KP_End) {
+ m.code = UI_KEYCODE_END;
+ } else if (symbol == XK_KP_Enter) {
+ m.code = UI_KEYCODE_ENTER;
+ } else if (symbol == XK_KP_Delete) {
+ m.code = UI_KEYCODE_DELETE;
+ }
+
+ _UIWindowInputEvent(window, UI_MSG_KEY_TYPED, 0, &m);
+ }
+ } else if (event->type == KeyRelease) {
+ UIWindow *window = _UIFindWindow(event->xkey.window);
+ if (!window) return false;
+
+ if (event->xkey.keycode == window->ctrlCode) {
+ window->ctrl = false;
+ _UIWindowInputEvent(window, UI_MSG_MOUSE_MOVE, 0, 0);
+ } else if (event->xkey.keycode == window->shiftCode) {
+ window->shift = false;
+ _UIWindowInputEvent(window, UI_MSG_MOUSE_MOVE, 0, 0);
+ } else if (event->xkey.keycode == window->altCode) {
+ window->alt = false;
+ _UIWindowInputEvent(window, UI_MSG_MOUSE_MOVE, 0, 0);
+ }
+ } else if (event->type == FocusIn) {
+ UIWindow *window = _UIFindWindow(event->xfocus.window);
+ if (!window) return false;
+ window->ctrl = window->shift = window->alt = false;
+ UIElementMessage(&window->e, UI_MSG_WINDOW_ACTIVATE, 0, 0);
+ } else if (event->type == ClientMessage && event->xclient.message_type == ui.dndEnterID) {
+ UIWindow *window = _UIFindWindow(event->xclient.window);
+ if (!window) return false;
+ window->dragSource = (Window) event->xclient.data.l[0];
+ } else if (event->type == ClientMessage && event->xclient.message_type == ui.dndPositionID) {
+ UIWindow *window = _UIFindWindow(event->xclient.window);
+ if (!window) return false;
+ XClientMessageEvent m = { 0 };
+ m.type = ClientMessage;
+ m.display = event->xclient.display;
+ m.window = (Window) event->xclient.data.l[0];
+ m.message_type = ui.dndStatusID;
+ m.format = 32;
+ m.data.l[0] = window->window;
+ m.data.l[1] = true;
+ m.data.l[4] = ui.dndActionCopyID;
+ XSendEvent(ui.display, m.window, False, NoEventMask, (XEvent *) &m);
+ XFlush(ui.display);
+ } else if (event->type == ClientMessage && event->xclient.message_type == ui.dndDropID) {
+ UIWindow *window = _UIFindWindow(event->xclient.window);
+ if (!window) return false;
+
+ // TODO Dropping text.
+
+ if (!XConvertSelection(ui.display, ui.dndSelectionID, ui.uriListID, ui.primaryID, window->window, event->xclient.data.l[2])) {
+ XClientMessageEvent m = { 0 };
+ m.type = ClientMessage;
+ m.display = ui.display;
+ m.window = window->dragSource;
+ m.message_type = ui.dndFinishedID;
+ m.format = 32;
+ m.data.l[0] = window->window;
+ m.data.l[1] = 0;
+ m.data.l[2] = ui.dndActionCopyID;
+ XSendEvent(ui.display, m.window, False, NoEventMask, (XEvent *) &m);
+ XFlush(ui.display);
+ }
+ } else if (event->type == SelectionNotify) {
+ UIWindow *window = _UIFindWindow(event->xselection.requestor);
+ if (!window) return false;
+ if (!window->dragSource) return false;
+
+ Atom type = None;
+ int format = 0;
+ uint64_t count = 0, bytesLeft = 0;
+ uint8_t *data = NULL;
+ XGetWindowProperty(ui.display, window->window, ui.primaryID, 0, 65536, False, AnyPropertyType, &type, &format, &count, &bytesLeft, &data);
+
+ if (format == 8 /* bits per character */) {
+ if (event->xselection.target == ui.uriListID) {
+ char *copy = (char *) UI_MALLOC(count);
+ int fileCount = 0;
+
+ for (int i = 0; i < (int) count; i++) {
+ copy[i] = data[i];
+
+ if (i && data[i - 1] == '\r' && data[i] == '\n') {
+ fileCount++;
+ }
+ }
+
+ char **files = (char **) UI_MALLOC(sizeof(char *) * fileCount);
+ fileCount = 0;
+
+ for (int i = 0; i < (int) count; i++) {
+ char *s = copy + i;
+ while (!(i && data[i - 1] == '\r' && data[i] == '\n' && i < (int) count)) i++;
+ copy[i - 1] = 0;
+
+ for (int j = 0; s[j]; j++) {
+ if (s[j] == '%' && s[j + 1] && s[j + 2]) {
+ char n[3];
+ n[0] = s[j + 1], n[1] = s[j + 2], n[2] = 0;
+ s[j] = strtol(n, NULL, 16);
+ if (!s[j]) break;
+ memmove(s + j + 1, s + j + 3, strlen(s) - j - 2);
+ }
+ }
+
+ if (s[0] == 'f' && s[1] == 'i' && s[2] == 'l' && s[3] == 'e' && s[4] == ':' && s[5] == '/' && s[6] == '/') {
+ files[fileCount++] = s + 7;
+ }
+ }
+
+ UIElementMessage(&window->e, UI_MSG_WINDOW_DROP_FILES, fileCount, files);
+
+ UI_FREE(files);
+ UI_FREE(copy);
+ } else if (event->xselection.target == ui.plainTextID) {
+ // TODO.
+ }
+ }
+
+ XFree(data);
+
+ XClientMessageEvent m = { 0 };
+ m.type = ClientMessage;
+ m.display = ui.display;
+ m.window = window->dragSource;
+ m.message_type = ui.dndFinishedID;
+ m.format = 32;
+ m.data.l[0] = window->window;
+ m.data.l[1] = true;
+ m.data.l[2] = ui.dndActionCopyID;
+ XSendEvent(ui.display, m.window, False, NoEventMask, (XEvent *) &m);
+ XFlush(ui.display);
+
+ window->dragSource = 0; // Drag complete.
+ _UIUpdate();
+ } else if (event->type == SelectionRequest) {
+ UIWindow *window = _UIFindWindow(event->xclient.window);
+ if (!window) return false;
+
+ if ((XGetSelectionOwner(ui.display, ui.clipboardID) == window->window)
+ && (event->xselectionrequest.selection == ui.clipboardID)) {
+ XSelectionRequestEvent requestEvent = event->xselectionrequest;
+ Atom utf8ID = XInternAtom(ui.display, "UTF8_STRING", 1);
+ if (utf8ID == None) utf8ID = XA_STRING;
+
+ Atom type = requestEvent.target;
+ type = (type == ui.textID) ? XA_STRING : type;
+ int changePropertyResult = 0;
+
+ if(requestEvent.target == XA_STRING || requestEvent.target == ui.textID || requestEvent.target == utf8ID) {
+ changePropertyResult = XChangeProperty(requestEvent.display, requestEvent.requestor, requestEvent.property,
+ type, 8, PropModeReplace, (const unsigned char *) ui.pasteText, strlen(ui.pasteText));
+ } else if (requestEvent.target == ui.targetID) {
+ changePropertyResult = XChangeProperty(requestEvent.display, requestEvent.requestor, requestEvent.property,
+ XA_ATOM, 32, PropModeReplace, (unsigned char *) &utf8ID, 1);
+ }
+
+ if(changePropertyResult == 0 || changePropertyResult == 1) {
+ XSelectionEvent sendEvent = {
+ .type = SelectionNotify,
+ .serial = requestEvent.serial,
+ .send_event = requestEvent.send_event,
+ .display = requestEvent.display,
+ .requestor = requestEvent.requestor,
+ .selection = requestEvent.selection,
+ .target = requestEvent.target,
+ .property = requestEvent.property,
+ .time = requestEvent.time
+ };
+
+ XSendEvent(ui.display, requestEvent.requestor, 0, 0, (XEvent *) &sendEvent);
+ }
+ }
+ }
+
+ return false;
+}
+
+bool _UIMessageLoopSingle(int *result) {
+ XEvent events[64];
+
+ if (ui.animating) {
+ if (XPending(ui.display)) {
+ XNextEvent(ui.display, events + 0);
+ } else {
+ _UIProcessAnimations();
+ return true;
+ }
+ } else {
+ XNextEvent(ui.display, events + 0);
+ }
+
+ int p = 1;
+
+ int configureIndex = -1, motionIndex = -1, exposeIndex = -1;
+
+ while (p < 64 && XPending(ui.display)) {
+ XNextEvent(ui.display, events + p);
+
+#define _UI_MERGE_EVENTS(a, b) \
+ if (events[p].type == a) { \
+ if (b != -1) events[b].type = 0; \
+ b = p; \
+ }
+
+ _UI_MERGE_EVENTS(ConfigureNotify, configureIndex);
+ _UI_MERGE_EVENTS(MotionNotify, motionIndex);
+ _UI_MERGE_EVENTS(Expose, exposeIndex);
+
+ p++;
+ }
+
+ for (int i = 0; i < p; i++) {
+ if (!events[i].type) {
+ continue;
+ }
+
+ if (_UIProcessEvent(events + i)) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+void UIWindowPostMessage(UIWindow *window, UIMessage message, void *_dp) {
+ // HACK! Xlib doesn't seem to have a nice way to do this,
+ // so send a specially crafted key press event instead.
+ // TODO Maybe ClientMessage is what this should use?
+ uintptr_t dp = (uintptr_t) _dp;
+ XKeyEvent event = { 0 };
+ event.display = ui.display;
+ event.window = window->window;
+ event.root = DefaultRootWindow(ui.display);
+ event.subwindow = None;
+ event.time = dp >> 32;
+ event.x = 0x7123;
+ event.y = 0x7456;
+ event.x_root = (dp >> 0) & 0xFFFF;
+ event.y_root = (dp >> 16) & 0xFFFF;
+ event.same_screen = True;
+ event.keycode = 1;
+ event.state = message;
+ event.type = KeyPress;
+ XSendEvent(ui.display, window->window, True, KeyPressMask, (XEvent *) &event);
+ XFlush(ui.display);
+}
+
+#endif
+
+#ifdef UI_WINDOWS
+
+const int UI_KEYCODE_A = 'A';
+const int UI_KEYCODE_0 = '0';
+const int UI_KEYCODE_BACKSPACE = VK_BACK;
+const int UI_KEYCODE_DELETE = VK_DELETE;
+const int UI_KEYCODE_DOWN = VK_DOWN;
+const int UI_KEYCODE_END = VK_END;
+const int UI_KEYCODE_ENTER = VK_RETURN;
+const int UI_KEYCODE_ESCAPE = VK_ESCAPE;
+const int UI_KEYCODE_F1 = VK_F1;
+const int UI_KEYCODE_HOME = VK_HOME;
+const int UI_KEYCODE_LEFT = VK_LEFT;
+const int UI_KEYCODE_RIGHT = VK_RIGHT;
+const int UI_KEYCODE_SPACE = VK_SPACE;
+const int UI_KEYCODE_TAB = VK_TAB;
+const int UI_KEYCODE_UP = VK_UP;
+const int UI_KEYCODE_INSERT = VK_INSERT;
+
+int _UIWindowMessage(UIElement *element, UIMessage message, int di, void *dp) {
+ if (message == UI_MSG_DESTROY) {
+ UIWindow *window = (UIWindow *) element;
+ _UIWindowDestroyCommon(window);
+ SetWindowLongPtr(window->hwnd, GWLP_USERDATA, 0);
+ DestroyWindow(window->hwnd);
+ }
+
+ return _UIWindowMessageCommon(element, message, di, dp);
+}
+
+LRESULT CALLBACK _UIWindowProcedure(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) {
+ UIWindow *window = (UIWindow *) GetWindowLongPtr(hwnd, GWLP_USERDATA);
+
+ if (!window || ui.assertionFailure) {
+ return DefWindowProc(hwnd, message, wParam, lParam);
+ }
+
+ if (message == WM_CLOSE) {
+ if (UIElementMessage(&window->e, UI_MSG_WINDOW_CLOSE, 0, 0)) {
+ _UIUpdate();
+ return 0;
+ } else {
+ PostQuitMessage(0);
+ }
+ } else if (message == WM_SIZE) {
+ RECT client;
+ GetClientRect(hwnd, &client);
+ window->width = client.right;
+ window->height = client.bottom;
+ window->bits = (uint32_t *) UI_REALLOC(window->bits, window->width * window->height * 4);
+ window->e.bounds = UI_RECT_2S(window->width, window->height);
+ window->e.clip = UI_RECT_2S(window->width, window->height);
+ UIElementMessage(&window->e, UI_MSG_LAYOUT, 0, 0);
+ _UIUpdate();
+ } else if (message == WM_MOUSEMOVE) {
+ if (!window->trackingLeave) {
+ window->trackingLeave = true;
+ TRACKMOUSEEVENT leave = { 0 };
+ leave.cbSize = sizeof(TRACKMOUSEEVENT);
+ leave.dwFlags = TME_LEAVE;
+ leave.hwndTrack = hwnd;
+ TrackMouseEvent(&leave);
+ }
+
+ POINT cursor;
+ GetCursorPos(&cursor);
+ ScreenToClient(hwnd, &cursor);
+ window->cursorX = cursor.x;
+ window->cursorY = cursor.y;
+ _UIWindowInputEvent(window, UI_MSG_MOUSE_MOVE, 0, 0);
+ } else if (message == WM_MOUSELEAVE) {
+ window->trackingLeave = false;
+
+ if (!window->pressed) {
+ window->cursorX = -1;
+ window->cursorY = -1;
+ }
+
+ _UIWindowInputEvent(window, UI_MSG_MOUSE_MOVE, 0, 0);
+ } else if (message == WM_LBUTTONDOWN) {
+ SetCapture(hwnd);
+ _UIWindowInputEvent(window, UI_MSG_LEFT_DOWN, 0, 0);
+ } else if (message == WM_LBUTTONUP) {
+ if (window->pressedButton == 1) ReleaseCapture();
+ _UIWindowInputEvent(window, UI_MSG_LEFT_UP, 0, 0);
+ } else if (message == WM_MBUTTONDOWN) {
+ SetCapture(hwnd);
+ _UIWindowInputEvent(window, UI_MSG_MIDDLE_DOWN, 0, 0);
+ } else if (message == WM_MBUTTONUP) {
+ if (window->pressedButton == 2) ReleaseCapture();
+ _UIWindowInputEvent(window, UI_MSG_MIDDLE_UP, 0, 0);
+ } else if (message == WM_RBUTTONDOWN) {
+ SetCapture(hwnd);
+ _UIWindowInputEvent(window, UI_MSG_RIGHT_DOWN, 0, 0);
+ } else if (message == WM_RBUTTONUP) {
+ if (window->pressedButton == 3) ReleaseCapture();
+ _UIWindowInputEvent(window, UI_MSG_RIGHT_UP, 0, 0);
+ } else if (message == WM_MOUSEWHEEL) {
+ int delta = (int) wParam >> 16;
+ _UIWindowInputEvent(window, UI_MSG_MOUSE_WHEEL, -delta, 0);
+ } else if (message == WM_KEYDOWN) {
+ window->ctrl = GetKeyState(VK_CONTROL) & 0x8000;
+ window->shift = GetKeyState(VK_SHIFT) & 0x8000;
+ window->alt = GetKeyState(VK_MENU) & 0x8000;
+
+ UIKeyTyped m = { 0 };
+ m.code = wParam;
+ _UIWindowInputEvent(window, UI_MSG_KEY_TYPED, 0, &m);
+ } else if (message == WM_CHAR) {
+ UIKeyTyped m = { 0 };
+ char c = wParam;
+ m.text = &c;
+ m.textBytes = 1;
+ _UIWindowInputEvent(window, UI_MSG_KEY_TYPED, 0, &m);
+ } else if (message == WM_PAINT) {
+ PAINTSTRUCT paint;
+ HDC dc = BeginPaint(hwnd, &paint);
+ BITMAPINFOHEADER info = { 0 };
+ info.biSize = sizeof(info);
+ info.biWidth = window->width, info.biHeight = -window->height;
+ info.biPlanes = 1, info.biBitCount = 32;
+ StretchDIBits(dc, 0, 0, UI_RECT_SIZE(window->e.bounds), 0, 0, UI_RECT_SIZE(window->e.bounds),
+ window->bits, (BITMAPINFO *) &info, DIB_RGB_COLORS, SRCCOPY);
+ EndPaint(hwnd, &paint);
+ } else if (message == WM_SETCURSOR && LOWORD(lParam) == HTCLIENT) {
+ SetCursor(ui.cursors[window->cursorStyle]);
+ return 1;
+ } else if (message == WM_SETFOCUS || message == WM_KILLFOCUS) {
+ _UIMenusClose();
+
+ if (message == WM_SETFOCUS) {
+ _UIInspectorSetFocusedWindow(window);
+ UIElementMessage(&window->e, UI_MSG_WINDOW_ACTIVATE, 0, 0);
+ }
+ } else if (message == WM_MOUSEACTIVATE && (window->e.flags & UI_WINDOW_MENU)) {
+ return MA_NOACTIVATE;
+ } else if (message == WM_DROPFILES) {
+ HDROP drop = (HDROP) wParam;
+ int count = DragQueryFile(drop, 0xFFFFFFFF, NULL, 0);
+ char **files = (char **) UI_MALLOC(sizeof(char *) * count);
+
+ for (int i = 0; i < count; i++) {
+ int length = DragQueryFile(drop, i, NULL, 0);
+ files[i] = (char *) UI_MALLOC(length + 1);
+ files[i][length] = 0;
+ DragQueryFile(drop, i, files[i], length + 1);
+ }
+
+ UIElementMessage(&window->e, UI_MSG_WINDOW_DROP_FILES, count, files);
+ for (int i = 0; i < count; i++) UI_FREE(files[i]);
+ UI_FREE(files);
+ DragFinish(drop);
+ _UIUpdate();
+ } else if (message == WM_APP + 1) {
+ UIElementMessage(&window->e, (UIMessage) wParam, 0, (void *) lParam);
+ _UIUpdate();
+ } else {
+ if (message == WM_NCLBUTTONDOWN || message == WM_NCMBUTTONDOWN || message == WM_NCRBUTTONDOWN) {
+ if (~window->e.flags & UI_WINDOW_MENU) {
+ _UIMenusClose();
+ _UIUpdate();
+ }
+ }
+
+ return DefWindowProc(hwnd, message, wParam, lParam);
+ }
+
+ return 0;
+}
+
+void UIInitialise() {
+ ui.heap = GetProcessHeap();
+
+ _UIInitialiseCommon();
+
+ ui.cursors[UI_CURSOR_ARROW] = LoadCursor(NULL, IDC_ARROW);
+ ui.cursors[UI_CURSOR_TEXT] = LoadCursor(NULL, IDC_IBEAM);
+ ui.cursors[UI_CURSOR_SPLIT_V] = LoadCursor(NULL, IDC_SIZENS);
+ ui.cursors[UI_CURSOR_SPLIT_H] = LoadCursor(NULL, IDC_SIZEWE);
+ ui.cursors[UI_CURSOR_FLIPPED_ARROW] = LoadCursor(NULL, IDC_ARROW);
+ ui.cursors[UI_CURSOR_CROSS_HAIR] = LoadCursor(NULL, IDC_CROSS);
+ ui.cursors[UI_CURSOR_HAND] = LoadCursor(NULL, IDC_HAND);
+ ui.cursors[UI_CURSOR_RESIZE_UP] = LoadCursor(NULL, IDC_SIZENS);
+ ui.cursors[UI_CURSOR_RESIZE_LEFT] = LoadCursor(NULL, IDC_SIZEWE);
+ ui.cursors[UI_CURSOR_RESIZE_UP_RIGHT] = LoadCursor(NULL, IDC_SIZENESW);
+ ui.cursors[UI_CURSOR_RESIZE_UP_LEFT] = LoadCursor(NULL, IDC_SIZENWSE);
+ ui.cursors[UI_CURSOR_RESIZE_DOWN] = LoadCursor(NULL, IDC_SIZENS);
+ ui.cursors[UI_CURSOR_RESIZE_RIGHT] = LoadCursor(NULL, IDC_SIZEWE);
+ ui.cursors[UI_CURSOR_RESIZE_DOWN_LEFT] = LoadCursor(NULL, IDC_SIZENESW);
+ ui.cursors[UI_CURSOR_RESIZE_DOWN_RIGHT] = LoadCursor(NULL, IDC_SIZENWSE);
+
+ WNDCLASS windowClass = { 0 };
+ windowClass.lpfnWndProc = _UIWindowProcedure;
+ windowClass.lpszClassName = "normal";
+ RegisterClass(&windowClass);
+ windowClass.style |= CS_DROPSHADOW;
+ windowClass.lpszClassName = "shadow";
+ RegisterClass(&windowClass);
+}
+
+bool _UIMessageLoopSingle(int *result) {
+ MSG message = { 0 };
+
+ if (ui.animating) {
+ if (PeekMessage(&message, NULL, 0, 0, PM_REMOVE)) {
+ if (message.message == WM_QUIT) {
+ *result = message.wParam;
+ return false;
+ }
+
+ TranslateMessage(&message);
+ DispatchMessage(&message);
+ } else {
+ _UIProcessAnimations();
+ }
+ } else {
+ if (!GetMessage(&message, NULL, 0, 0)) {
+ *result = message.wParam;
+ return false;
+ }
+
+ TranslateMessage(&message);
+ DispatchMessage(&message);
+ }
+
+ return true;
+}
+
+void UIMenuShow(UIMenu *menu) {
+ int width, height;
+ _UIMenuPrepare(menu, &width, &height);
+ MoveWindow(menu->e.window->hwnd, menu->pointX, menu->pointY, width, height, FALSE);
+ ShowWindow(menu->e.window->hwnd, SW_SHOWNOACTIVATE);
+}
+
+UIWindow *UIWindowCreate(UIWindow *owner, uint32_t flags, const char *cTitle, int width, int height) {
+ _UIMenusClose();
+
+ UIWindow *window = (UIWindow *) UIElementCreate(sizeof(UIWindow), NULL, flags | UI_ELEMENT_WINDOW, _UIWindowMessage, "Window");
+ _UIWindowAdd(window);
+ if (owner) window->scale = owner->scale;
+
+ if (flags & UI_WINDOW_MENU) {
+ UI_ASSERT(owner);
+
+ window->hwnd = CreateWindowEx(WS_EX_TOPMOST | WS_EX_NOACTIVATE, "shadow", 0, WS_POPUP,
+ 0, 0, 0, 0, owner->hwnd, NULL, NULL, NULL);
+ } else {
+ window->hwnd = CreateWindowEx(WS_EX_ACCEPTFILES, "normal", cTitle, WS_OVERLAPPEDWINDOW,
+ CW_USEDEFAULT, CW_USEDEFAULT, width ? width : CW_USEDEFAULT, height ? height : CW_USEDEFAULT,
+ owner ? owner->hwnd : NULL, NULL, NULL, NULL);
+ }
+
+ SetWindowLongPtr(window->hwnd, GWLP_USERDATA, (LONG_PTR) window);
+
+ if (~flags & UI_WINDOW_MENU) {
+ ShowWindow(window->hwnd, SW_SHOW);
+ PostMessage(window->hwnd, WM_SIZE, 0, 0);
+ }
+
+ return window;
+}
+
+void _UIWindowEndPaint(UIWindow *window, UIPainter *painter) {
+ HDC dc = GetDC(window->hwnd);
+ BITMAPINFOHEADER info = { 0 };
+ info.biSize = sizeof(info);
+ info.biWidth = window->width, info.biHeight = window->height;
+ info.biPlanes = 1, info.biBitCount = 32;
+ StretchDIBits(dc,
+ UI_RECT_TOP_LEFT(window->updateRegion), UI_RECT_SIZE(window->updateRegion),
+ window->updateRegion.l, window->updateRegion.b + 1,
+ UI_RECT_WIDTH(window->updateRegion), -UI_RECT_HEIGHT(window->updateRegion),
+ window->bits, (BITMAPINFO *) &info, DIB_RGB_COLORS, SRCCOPY);
+ ReleaseDC(window->hwnd, dc);
+}
+
+void _UIWindowSetCursor(UIWindow *window, int cursor) {
+ SetCursor(ui.cursors[cursor]);
+}
+
+void _UIWindowGetScreenPosition(UIWindow *window, int *_x, int *_y) {
+ POINT p;
+ p.x = 0;
+ p.y = 0;
+ ClientToScreen(window->hwnd, &p);
+ *_x = p.x;
+ *_y = p.y;
+}
+
+void UIWindowPostMessage(UIWindow *window, UIMessage message, void *_dp) {
+ PostMessage(window->hwnd, WM_APP + 1, (WPARAM) message, (LPARAM) _dp);
+}
+
+void *_UIHeapReAlloc(void *pointer, size_t size) {
+ if (pointer) {
+ if (size) {
+ return HeapReAlloc(ui.heap, 0, pointer, size);
+ } else {
+ UI_FREE(pointer);
+ return NULL;
+ }
+ } else {
+ if (size) {
+ return UI_MALLOC(size);
+ } else {
+ return NULL;
+ }
+ }
+}
+
+void _UIClipboardWriteText(UIWindow *window, char *text) {
+ if (OpenClipboard(window->hwnd)) {
+ EmptyClipboard();
+ HGLOBAL memory = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, _UIStringLength(text) + 1);
+ char *copy = (char *) GlobalLock(memory);
+ for (uintptr_t i = 0; text[i]; i++) copy[i] = text[i];
+ GlobalUnlock(copy);
+ SetClipboardData(CF_TEXT, memory);
+ CloseClipboard();
+ }
+}
+
+char *_UIClipboardReadTextStart(UIWindow *window, size_t *bytes) {
+ if (!OpenClipboard(window->hwnd)) {
+ return NULL;
+ }
+
+ HANDLE memory = GetClipboardData(CF_TEXT);
+
+ if (!memory) {
+ CloseClipboard();
+ return NULL;
+ }
+
+ char *buffer = (char *) GlobalLock(memory);
+
+ if (!buffer) {
+ CloseClipboard();
+ return NULL;
+ }
+
+ size_t byteCount = GlobalSize(memory);
+
+ if (byteCount < 1) {
+ GlobalUnlock(memory);
+ CloseClipboard();
+ return NULL;
+ }
+
+ char *copy = (char *) UI_MALLOC(byteCount + 1);
+ for (uintptr_t i = 0; i < byteCount; i++) copy[i] = buffer[i];
+ copy[byteCount] = 0; // Just in case.
+
+ GlobalUnlock(memory);
+ CloseClipboard();
+
+ if (bytes) *bytes = _UIStringLength(copy);
+ return copy;
+}
+
+void _UIClipboardReadTextEnd(UIWindow *window, char *text) {
+ UI_FREE(text);
+}
+
+#endif
+
+#ifdef UI_ESSENCE
+
+const int UI_KEYCODE_A = ES_SCANCODE_A;
+const int UI_KEYCODE_0 = ES_SCANCODE_0;
+const int UI_KEYCODE_BACKSPACE = ES_SCANCODE_BACKSPACE;
+const int UI_KEYCODE_DELETE = ES_SCANCODE_DELETE;
+const int UI_KEYCODE_DOWN = ES_SCANCODE_DOWN_ARROW;
+const int UI_KEYCODE_END = ES_SCANCODE_END;
+const int UI_KEYCODE_ENTER = ES_SCANCODE_ENTER;
+const int UI_KEYCODE_ESCAPE = ES_SCANCODE_ESCAPE;
+const int UI_KEYCODE_F1 = ES_SCANCODE_F1;
+const int UI_KEYCODE_HOME = ES_SCANCODE_HOME;
+const int UI_KEYCODE_LEFT = ES_SCANCODE_LEFT_ARROW;
+const int UI_KEYCODE_RIGHT = ES_SCANCODE_RIGHT_ARROW;
+const int UI_KEYCODE_SPACE = ES_SCANCODE_SPACE;
+const int UI_KEYCODE_TAB = ES_SCANCODE_TAB;
+const int UI_KEYCODE_UP = ES_SCANCODE_UP_ARROW;
+const int UI_KEYCODE_INSERT = ES_SCANCODE_INSERT;
+
+int _UIWindowMessage(UIElement *element, UIMessage message, int di, void *dp) {
+ if (message == UI_MSG_DESTROY) {
+ // TODO Non-main windows.
+ element->window = NULL;
+ EsInstanceDestroy(ui.instance);
+ }
+
+ return _UIWindowMessageCommon(element, message, di, dp);
+}
+
+void UIInitialise() {
+ _UIInitialiseCommon();
+
+ while (true) {
+ EsMessage *message = EsMessageReceive();
+
+ if (message->type == ES_MSG_INSTANCE_CREATE) {
+ ui.instance = EsInstanceCreate(message, NULL, 0);
+ break;
+ }
+ }
+}
+
+bool _UIMessageLoopSingle(int *result) {
+ if (ui.animating) {
+ // TODO.
+ } else {
+ _UIMessageProcess(EsMessageReceive());
+ }
+
+ return true;
+}
+
+UIMenu *UIMenuCreate(UIElement *parent, uint32_t flags) {
+ ui.menuIndex = 0;
+ return EsMenuCreate(parent->window->window, ES_MENU_AT_CURSOR);
+}
+
+void _UIMenuItemCallback(EsMenu *menu, EsGeneric context) {
+ ((void (*)(void *)) ui.menuData[context.u * 2 + 0])(ui.menuData[context.u * 2 + 1]);
+}
+
+void UIMenuAddItem(UIMenu *menu, uint32_t flags, const char *label, ptrdiff_t labelBytes, void (*invoke)(void *cp), void *cp) {
+ EsAssert(ui.menuIndex < 128);
+ ui.menuData[ui.menuIndex * 2 + 0] = (void *) invoke;
+ ui.menuData[ui.menuIndex * 2 + 1] = cp;
+ EsMenuAddItem(menu, (flags & UI_BUTTON_CHECKED) ? ES_MENU_ITEM_CHECKED : ES_FLAGS_DEFAULT,
+ label, labelBytes, _UIMenuItemCallback, ui.menuIndex);
+ ui.menuIndex++;
+}
+
+void UIMenuShow(UIMenu *menu) {
+ EsMenuShow(menu);
+}
+
+int _UIWindowCanvasMessage(EsElement *element, EsMessage *message) {
+ UIWindow *window = (UIWindow *) element->window->userData.p;
+
+ if (!window) {
+ return 0;
+ } else if (message->type == ES_MSG_PAINT) {
+ EsRectangle bounds = ES_RECT_4PD(message->painter->offsetX, message->painter->offsetY, window->width, window->height);
+ EsDrawBitmap(message->painter, bounds, window->bits, window->width * 4, 0xFFFF);
+ } else if (message->type == ES_MSG_LAYOUT) {
+ EsElementGetSize(element, &window->width, &window->height);
+ window->bits = (uint32_t *) UI_REALLOC(window->bits, window->width * window->height * 4);
+ window->e.bounds = UI_RECT_2S(window->width, window->height);
+ window->e.clip = UI_RECT_2S(window->width, window->height);
+ UIElementMessage(&window->e, UI_MSG_LAYOUT, 0, 0);
+ _UIUpdate();
+ } else if (message->type == ES_MSG_SCROLL_WHEEL) {
+ _UIWindowInputEvent(window, UI_MSG_MOUSE_WHEEL, -message->scrollWheel.dy, 0);
+ } else if (message->type == ES_MSG_MOUSE_MOVED || message->type == ES_MSG_HOVERED_END
+ || message->type == ES_MSG_MOUSE_LEFT_DRAG || message->type == ES_MSG_MOUSE_RIGHT_DRAG || message->type == ES_MSG_MOUSE_MIDDLE_DRAG) {
+ EsPoint point = EsMouseGetPosition(element);
+ window->cursorX = point.x, window->cursorY = point.y;
+ _UIWindowInputEvent(window, UI_MSG_MOUSE_MOVE, 0, 0);
+ } else if (message->type == ES_MSG_KEY_UP) {
+ window->ctrl = EsKeyboardIsCtrlHeld();
+ window->shift = EsKeyboardIsShiftHeld();
+ window->alt = EsKeyboardIsAltHeld();
+ } else if (message->type == ES_MSG_KEY_DOWN) {
+ window->ctrl = EsKeyboardIsCtrlHeld();
+ window->shift = EsKeyboardIsShiftHeld();
+ window->alt = EsKeyboardIsAltHeld();
+ UIKeyTyped m = { 0 };
+ char c[64];
+ m.text = c;
+ m.textBytes = EsMessageGetInputText(message, c);
+ m.code = message->keyboard.scancode;
+ return _UIWindowInputEvent(window, UI_MSG_KEY_TYPED, 0, &m) ? ES_HANDLED : 0;
+ } else if (message->type == ES_MSG_MOUSE_LEFT_CLICK) {
+ _UIInspectorSetFocusedWindow(window);
+ } else if (message->type == ES_MSG_USER_START) {
+ UIElementMessage(&window->e, (UIMessage) message->user.context1.u, 0, (void *) message->user.context2.p);
+ _UIUpdate();
+ } else if (message->type == ES_MSG_GET_CURSOR) {
+ message->cursorStyle = ES_CURSOR_NORMAL;
+ if (window->cursor == UI_CURSOR_TEXT) message->cursorStyle = ES_CURSOR_TEXT;
+ if (window->cursor == UI_CURSOR_SPLIT_V) message->cursorStyle = ES_CURSOR_SPLIT_VERTICAL;
+ if (window->cursor == UI_CURSOR_SPLIT_H) message->cursorStyle = ES_CURSOR_SPLIT_HORIZONTAL;
+ if (window->cursor == UI_CURSOR_FLIPPED_ARROW) message->cursorStyle = ES_CURSOR_SELECT_LINES;
+ if (window->cursor == UI_CURSOR_CROSS_HAIR) message->cursorStyle = ES_CURSOR_CROSS_HAIR_PICK;
+ if (window->cursor == UI_CURSOR_HAND) message->cursorStyle = ES_CURSOR_HAND_HOVER;
+ if (window->cursor == UI_CURSOR_RESIZE_UP) message->cursorStyle = ES_CURSOR_RESIZE_VERTICAL;
+ if (window->cursor == UI_CURSOR_RESIZE_LEFT) message->cursorStyle = ES_CURSOR_RESIZE_HORIZONTAL;
+ if (window->cursor == UI_CURSOR_RESIZE_UP_RIGHT) message->cursorStyle = ES_CURSOR_RESIZE_DIAGONAL_1;
+ if (window->cursor == UI_CURSOR_RESIZE_UP_LEFT) message->cursorStyle = ES_CURSOR_RESIZE_DIAGONAL_2;
+ if (window->cursor == UI_CURSOR_RESIZE_DOWN) message->cursorStyle = ES_CURSOR_RESIZE_VERTICAL;
+ if (window->cursor == UI_CURSOR_RESIZE_RIGHT) message->cursorStyle = ES_CURSOR_RESIZE_HORIZONTAL;
+ if (window->cursor == UI_CURSOR_RESIZE_DOWN_RIGHT) message->cursorStyle = ES_CURSOR_RESIZE_DIAGONAL_1;
+ if (window->cursor == UI_CURSOR_RESIZE_DOWN_LEFT) message->cursorStyle = ES_CURSOR_RESIZE_DIAGONAL_2;
+ }
+
+ else if (message->type == ES_MSG_MOUSE_LEFT_DOWN) _UIWindowInputEvent(window, UI_MSG_LEFT_DOWN, 0, 0);
+ else if (message->type == ES_MSG_MOUSE_LEFT_UP) _UIWindowInputEvent(window, UI_MSG_LEFT_UP, 0, 0);
+ else if (message->type == ES_MSG_MOUSE_MIDDLE_DOWN) _UIWindowInputEvent(window, UI_MSG_MIDDLE_DOWN, 0, 0);
+ else if (message->type == ES_MSG_MOUSE_MIDDLE_UP) _UIWindowInputEvent(window, UI_MSG_MIDDLE_UP, 0, 0);
+ else if (message->type == ES_MSG_MOUSE_RIGHT_DOWN) _UIWindowInputEvent(window, UI_MSG_RIGHT_DOWN, 0, 0);
+ else if (message->type == ES_MSG_MOUSE_RIGHT_UP) _UIWindowInputEvent(window, UI_MSG_RIGHT_UP, 0, 0);
+
+ else return 0;
+
+ return ES_HANDLED;
+}
+
+UIWindow *UIWindowCreate(UIWindow *owner, uint32_t flags, const char *cTitle, int width, int height) {
+ _UIMenusClose();
+
+ UIWindow *window = (UIWindow *) UIElementCreate(sizeof(UIWindow), NULL, flags | UI_ELEMENT_WINDOW, _UIWindowMessage, "Window");
+ _UIWindowAdd(window);
+ if (owner) window->scale = owner->scale;
+
+ if (flags & UI_WINDOW_MENU) {
+ // TODO.
+ } else {
+ // TODO Non-main windows.
+ window->window = ui.instance->window;
+ window->window->userData = window;
+ window->canvas = EsCustomElementCreate(window->window, ES_CELL_FILL | ES_ELEMENT_FOCUSABLE);
+ window->canvas->messageUser = _UIWindowCanvasMessage;
+ EsWindowSetTitle(window->window, cTitle, -1);
+ EsElementFocus(window->canvas);
+ }
+
+ return window;
+}
+
+void _UIWindowEndPaint(UIWindow *window, UIPainter *painter) {
+ EsElementRepaint(window->canvas, &window->updateRegion);
+}
+
+void _UIWindowSetCursor(UIWindow *window, int cursor) {
+ window->cursor = cursor;
+}
+
+void _UIWindowGetScreenPosition(UIWindow *window, int *_x, int *_y) {
+ EsRectangle r = EsElementGetScreenBounds(window->window);
+ *_x = r.l, *_y = r.t;
+}
+
+void UIWindowPostMessage(UIWindow *window, UIMessage message, void *_dp) {
+ EsMessage m = {};
+ m.type = ES_MSG_USER_START;
+ m.user.context1.u = message;
+ m.user.context2.p = _dp;
+ EsMessagePost(window->canvas, &m);
+}
+
+void _UIClipboardWriteText(UIWindow *window, char *text) {
+ EsClipboardAddText(ES_CLIPBOARD_PRIMARY, text, -1);
+ UI_FREE(text);
+}
+
+char *_UIClipboardReadTextStart(UIWindow *window, size_t *bytes) {
+ return EsClipboardReadText(ES_CLIPBOARD_PRIMARY, bytes, NULL);
+}
+
+void _UIClipboardReadTextEnd(UIWindow *window, char *text) {
+ EsHeapFree(text);
+}
+
+#endif
+
+#endif
diff --git a/main.c b/main.c
index 91075f1..c350331 100644
--- a/main.c
+++ b/main.c
@@ -1,67 +1,134 @@
-#include "memory.h"
-#include "plat.h"
-#include "rcache.h"
-#include "ui.h"
+#include <stdio.h>
+#include "config.h"
#include "library.h"
+#include "luigi.h"
+#include "memory.h"
-UI* ui;
-Library* lib;
+Library lib;
-Font* ffont;
-void prog_init(void* memory) {
- Heap* fh;
- unsigned char* bin;
- int bin_size;
- int fhs = 1024 * 1024 * 4;
- Font* font;
- memory_init(memory);
- rc_init();
- fh = galloc(sizeof *fh);
- init_heap(fh, galloc(fhs), fhs);
- bin = load_binary(default_font_location, &bin_size);
- font = new_font(fh, bin, default_font_size);
- ui = stack_alloc(sizeof *ui);
- init_ui(ui, font);
- lib = stack_alloc(sizeof *lib);
- init_library(lib);
- build_library(lib, library_folder);
+int libtab_msg(
+ UIElement *el,
+ UIMessage msg,
+ int di,
+ void *dp
+) {
+ if (msg == UI_MSG_TABLE_GET_ITEM) {
+ UITableGetItem *m = (UITableGetItem*)dp;
+ Song* song;
+ song = &lib.songs[lib.indices[m->index]];
+ m->isSelected = 0;
+ switch (m->column) {
+ case 0:
+ return snprintf(
+ m->buffer,
+ m->bufferBytes,
+ "%s",
+ song->name
+ );
+ case 1:
+ return snprintf(
+ m->buffer,
+ m->bufferBytes,
+ "%s",
+ song->artist
+ );
+ case 2:
+ return snprintf(
+ m->buffer,
+ m->bufferBytes,
+ "%s",
+ song->album
+ );
+ case 3:
+ return snprintf(
+ m->buffer,
+ m->bufferBytes,
+ "%s",
+ song->path
+ );
+ default: return 0;
+ }
+ }
+ return 0;
}
-void prog_update(void) {
- Rectangle l, r, lc, list;
- int h, i, c;
- rc_begin();
- ui_begin(ui, &l);
- rc_add_cmd_rect(&l, theme_background_colour);
-
- r = rectcut_right(&l, l.w / 2);
- h = font_height(ui->font) + theme_padding * 2;
- c = lib->song_count;
- lc.x = 0;
- lc.y = 0;
- lc.w = r.w - theme_padding * 2;
- lc.h = h * c + theme_padding * (c - 1);
- ui_container(
- ui,
- &r,
- &lc,
- &lc
+int prog_main(void* mem) {
+ Arena liba;
+ UIWindow* wi;
+ UISplitPane* split1, * split2, * split3;
+ UIPanel* plib, * pctrl, * plist, * pqueue;
+ UITable* libtab;
+ memory_init(mem);
+ init_arena(
+ &liba,
+ galloc(library_memory_size),
+ library_memory_size
+ );
+ build_library(&liba, &lib, library_path);
+ UIInitialise();
+ wi = UIWindowCreate(
+ 0,
+ 0,
+ app_name,
+ default_window_w,
+ default_window_h
+ );
+ split1 = UISplitPaneCreate(
+ &wi->e,
+ 0,
+ 0.3f
+ );
+ split3 = UISplitPaneCreate(
+ &split1->e,
+ UI_SPLIT_PANE_VERTICAL,
+ 0.5f
);
- list = lc;
- list.h = h;
- for (i = 0; i < max_songs; i++) {
- Song* song = &lib->songs[i];
- if (song->file[0]) {
- ui_button(ui, &list, song->name);
- list.y += list.h + theme_padding;
- }
- }
- rc_add_cmd_reset_clip();
- ui_end(ui);
- rc_flush();
-}
+ split2 = UISplitPaneCreate(
+ &split1->e,
+ 0,
+ 0.5f
+ );
+ pctrl = UIPanelCreate(&split3->e, UI_PANEL_GRAY);
+ pctrl->gap = 5;
+ pctrl->border = UI_RECT_1(5);
+
+ pqueue = UIPanelCreate(&split3->e, UI_PANEL_GRAY);
+ pqueue->gap = 5;
+ pqueue->border = UI_RECT_1(5);
+ UILabelCreate(
+ &pqueue->e,
+ 0,
+ "Queue",
+ 5
+ );
-void prog_deinit(void) {
+ plist = UIPanelCreate(&split2->e, UI_PANEL_GRAY);
+ plist->gap = 5;
+ plist->border = UI_RECT_1(5);
+ UILabelCreate(
+ &plist->e,
+ 0,
+ "Playlist",
+ 8
+ );
+ plib = UIPanelCreate(&split2->e, UI_PANEL_GRAY);
+ plib->gap = 5;
+ plib->border = UI_RECT_1(5);
+ UILabelCreate(
+ &plib->e,
+ 0,
+ "Library",
+ 7
+ );
+ libtab = UITableCreate(
+ &plib->e,
+ UI_ELEMENT_H_FILL | UI_ELEMENT_V_FILL,
+ "Track\tArtist\tAlbum\tFilename"
+ );
+ libtab->itemCount = lib.cnt;
+ libtab->e.messageUser = libtab_msg;
+ UITableResizeColumns(libtab);
+ return UIMessageLoop();
}
diff --git a/maths.h b/maths.h
deleted file mode 100644
index b446c9a..0000000
--- a/maths.h
+++ /dev/null
@@ -1,9 +0,0 @@
-#ifndef maths_h
-#define maths_h
-
-#define mini(a_, b_) ((a_) < (b_) ? (a_) : (b_))
-#define maxi(a_, b_) ((a_) > (b_) ? (a_) : (b_))
-#define sign(n_) ((n_ < 0) ? -1 : 1)
-#define clamp(v_, min_, max_) (maxi(min_, mini(max_, v_)))
-
-#endif
diff --git a/memory.c b/memory.c
index 9dd99c2..f35ed51 100644
--- a/memory.c
+++ b/memory.c
@@ -75,7 +75,6 @@ static void* heap_alloc_impla(Heap* h, int size) {
as = size + sizeof *header;
p = 0;
m = sizeof *header;
- h->usage += as;
for (i = 0; i < h->blocks; i++) {
header = (int*)(h->buffer + p);
s = header[0];
@@ -87,9 +86,11 @@ static void* heap_alloc_impla(Heap* h, int size) {
header[0] = (s << 1);
nh = (int*)(h->buffer + p + s);
nh[0] = (as << 1) | 1;
+ h->usage += as;
h->blocks++;
return nh + 1;
} else if (s == as) {
+ h->usage += as;
header[0] |= 1;
return header + 1;
}
@@ -203,6 +204,11 @@ void heap_free(Heap* h, void* ptr) {
heap_free_aligned(h, ptr);
}
+int heap_block_size(void* ptr) {
+ int h = ((int*)ptr)[-1];
+ return h >> 1;
+}
+
void* galloc(int size) {
#if use_system_malloc
return malloc(size);
diff --git a/memory.h b/memory.h
index 7ee6f53..90b89d2 100644
--- a/memory.h
+++ b/memory.h
@@ -23,6 +23,7 @@ void* heap_alloc_aligned(Heap* h, int size, int align);
void heap_free_aligned(Heap* h, void* ptr);
void* heap_alloc(Heap* h, int size);
void heap_free(Heap* h, void* ptr);
+int heap_block_size(void* ptr);
void* galloc(int size);
void gfree(void* ptr);
diff --git a/plat.c b/plat.c
index e9c71ba..c947b71 100644
--- a/plat.c
+++ b/plat.c
@@ -1,82 +1,66 @@
#include "plat.h"
#include "config.h"
-extern void prog_init(void*);
-extern void prog_update(void);
-extern void prog_deinit(void);
-
#ifdef plat_posix
#define _POSIX_SOURCE
#define _GNU_SOURCE
-#include "std_printers.c"
-#include <dirent.h>
-#include <fcntl.h>
-#include <signal.h>
+#include <stdarg.h>
#include <stdio.h>
+#include <unistd.h>
#include <stdlib.h>
+#include <dirent.h>
#include <string.h>
-#include <sys/stat.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <time.h>
-#include <unistd.h>
-static clockid_t global_clock;
-static unsigned long global_freq;
+extern int fileno(FILE*);
-void init_timer(void) {
- struct timespec ts;
+void print(const char* fmt, ...) {
+ va_list args;
+ va_start(args, fmt);
+ vfprintf(stdout, fmt, args);
+ va_end(args);
+}
- global_clock = CLOCK_REALTIME;
- global_freq = 1000000000;
+void print_err(const char* fmt, ...) {
+ va_list args;
+ va_start(args, fmt);
-#if defined(_POSIX_MONOTONIC_CLOCK)
- if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {
- global_clock = CLOCK_MONOTONIC;
+ if (isatty(fileno(stderr))) {
+ fprintf(stderr, "\033[31;31m");
}
-#endif
-}
-static unsigned long get_timer() {
- struct timespec ts;
+ vfprintf(stderr, fmt, args);
- clock_gettime(global_clock, &ts);
- return
- (unsigned long)ts.tv_sec * global_freq +
- (unsigned long)ts.tv_nsec;
-}
+ if (isatty(fileno(stderr))) {
+ fprintf(stderr, "\033[0m");
+ }
-unsigned long get_current_time() {
- return get_timer();
+ va_end(args);
}
-void sleep_ns(unsigned long ns) {
- struct timespec t = { 0 };
- t.tv_nsec = ns;
- nanosleep(&t, &t);
-}
+void print_war(const char* fmt, ...) {
+ va_list args;
+ va_start(args, fmt);
+
+ if (isatty(fileno(stderr))) {
+ fprintf(stderr, "\033[31;35m");
+ }
-unsigned char* load_binary(const char* n, int* size) {
- FILE* f;
- int s;
- void* b;
- f = fopen(n, "r");
- if (!f) {
- print_err("Failed to open %s.\n", n);
- pbreak(error_file_not_found);
- return 0;
+ vfprintf(stderr, fmt, args);
+
+ if (isatty(fileno(stderr))) {
+ fprintf(stderr, "\033[0m");
}
- fseek(f, 0, SEEK_END);
- s = ftell(f);
- rewind(f);
- b = malloc(s);
- s = fread(b, 1, s, f);
- if (size) *size = s;
- return b;
+
+ va_end(args);
}
-void free_file(void* p) {
- free(p);
+void pbreak(Error code) {
+#if defined(DEBUG) && defined(plat_x86)
+ __asm__("int3;");
+ (void)code;
+#else
+ exit(code);
+#endif
}
void iter_dir(const char* path, Dir_Iter fn, void* u) {
@@ -104,359 +88,18 @@ void iter_dir(const char* path, Dir_Iter fn, void* u) {
else
fn(u, buf);
}
+ closedir(di);
}
-#endif
-
-#ifdef plat_x11
-
-#define Font RX11Font
-#include <stdlib.h>
-#include <X11/Xlib.h>
-#include <X11/Xutil.h>
-#undef RX11Font
-
-#include "rcache.h"
-
-#define txt_buf_max 32
-
-struct {
- int w, h, run;
- Display* d;
- Window wi;
- GC gc;
- XImage* bb;
- Colour* bp, * fb;
- Atom wm_p, wm_d;
- char txt_buf[txt_buf_max];
- char raw_buf[txt_buf_max];
- int txt_len;
- int mx, my, scrx, scry;
-} app;
-static MBtn mheld_btns[mbtn_count];
-static MBtn mpressed_btns[mbtn_count];
-static MBtn mreleased_btns[mbtn_count];
-
-static void reset_keys(void) {
- int i;
- for (i = 0; i < mbtn_count; i++) {
- mpressed_btns[i] = 0;
- mreleased_btns[i] = 0;
- }
-}
-
-void init_app_render(const XWindowAttributes* wa) {
- Colour* p, * fb;
- Display* d;
- XImage* bb;
- int w, h;
- d = app.d;
- w = app.w;
- h = app.h;
- p = (Colour*)malloc(sizeof *p * w * h);
- fb = (Colour*)malloc(sizeof *fb * w * h);
- bb = app.bb;
- if (bb) {
- XDestroyImage(bb);
- }
- if (!p) {
- print_err("Out of memory.\n");
- pbreak(error_out_of_memory);
- }
- bb = XCreateImage(
- d,
- wa->visual,
- wa->depth,
- ZPixmap,
- 0,
- (char*)p,
- w,
- h,
- 32,
- w * sizeof *p
- );
- if (!bb) {
- print_err("Failed to create X11 backbuffer.\n");
- pbreak(error_platform_error);
- }
- app.bp = p;
- app.fb = fb;
- app.bb = bb;
-}
-
-void init_app(void) {
- Window w, r;
- Display* d;
- GC gc;
- unsigned rm, bm;
- XWindowAttributes wa;
- app.run = 0;
- d = XOpenDisplay(0);
- if (!d) {
- print_err("Failed to open X11 display.\n");
- pbreak(error_platform_error);
- return;
- }
- r = DefaultRootWindow(d);
- app.wm_p = XInternAtom(
- d,
- "WM_PROTOCOLS",
- 0
- );
- app.wm_d = XInternAtom(
- d,
- "WM_DELETE_WINDOW",
- 0
- );
- w = XCreateSimpleWindow(
- d,
- r,
- 0,
- 0,
- default_window_w,
- default_window_h,
- 0,
- WhitePixel(d, 0),
- BlackPixel(d, 0)
- );
- XSetWMProtocols(d, w, &app.wm_d, 1);
- XStoreName(d, w, app_name);
- XSelectInput(
- d,
- w,
- ExposureMask |
- KeyPressMask |
- KeyReleaseMask |
- PointerMotionMask |
- ButtonPressMask |
- ButtonReleaseMask
- );
- XClearWindow(d, w);
- XMapRaised(d, w);
- gc = XCreateGC(d, w, 0, 0);
- if (!gc) {
- print_err("Failed to create graphics context.\n");
- pbreak(error_platform_error);
- return;
- }
- XGetWindowAttributes(d, w, &wa);
- if (wa.depth != 24 && wa.depth != 32) {
- print_err("Only true colour displays are supported.\n");
- pbreak(error_platform_error);
- }
- rm = wa.visual->red_mask & 0x1000000;
- bm = wa.visual->blue_mask & 0xffffff;
- if ((rm == 0xff && bm == 0xff0000)) {
- print_war("Detected BGR. Colours will look fucked.\n");
- }
- app.d = d;
- app.gc = gc;
- app.w = wa.width;
- app.h = wa.height;
- app.run = 1;
- app.wi = w;
- app.bb = 0;
- init_app_render(&wa);
-}
-
-void deinit_app(void) {
- XDestroyWindow(app.d, app.wi);
- XDestroyImage(app.bb);
- XCloseDisplay(app.d);
-}
+extern int prog_main(void*);
-void update_events(void) {
- XWindowAttributes wa;
- Display* d;
- Window w;
- XEvent e;
- Rectangle r;
- int mb;
- d = app.d;
- w = app.wi;
- reset_keys();
- app.scrx = app.scry = 0;
- while (XPending(d)) {
- XNextEvent(d, &e);
- switch (e.type) {
- case ClientMessage:
- if (
- (Atom)e.xclient.data.l[0] ==
- app.wm_d
- ) {
- app.run = 0;
- }
- break;
- case Expose:
- XGetWindowAttributes(d, w, &wa);
- if (
- wa.width != app.w ||
- wa.height != app.h
- ) {
- app.w = wa.width;
- app.h = wa.height;
- init_app_render(&wa);
- }
- r.x = 0;
- r.y = 0;
- r.w = app.w;
- r.h = app.h;
- rc_invalidate(&r);
- break;
- case MotionNotify:
- app.mx = e.xmotion.x;
- app.my = e.xmotion.y;
- break;
- case ButtonPress:
- switch (e.xbutton.button) {
- case 1:
- case 2:
- case 3:
- mb = e.xbutton.button - 1;
- mheld_btns[mb] = 1;
- mpressed_btns[mb] = 1;
- break;
- }
- break;
- case ButtonRelease:
- switch (e.xbutton.button) {
- case 1:
- case 2:
- case 3:
- mb = e.xbutton.button - 1;
- mheld_btns[mb] = 0;
- mreleased_btns[mb] = 1;
- break;
- case 4:
- app.scry--;
- break;
- case 5:
- app.scry++;
- break;
- case 6:
- app.scrx--;
- break;
- case 7:
- app.scrx++;
- break;
- }
- break;
- default:
- break;
- }
- }
-}
-
-int main(int argc, const char** argv) {
+int main() {
+ int r;
void* mem;
- unsigned long now, next;
- long ts;
- (void)argc;
- (void)argv;
- init_timer();
mem = malloc(memory_size);
- if (!mem) {
- print_err("Out of memory.\n");
- return error_out_of_memory;
- }
- init_app();
- next = get_current_time();
- prog_init(mem);
- while (app.run) {
- now = get_current_time();
- while (now >= next) {
- update_events();
- prog_update();
- next += ms_per_frame * 1000000;
- }
- ts = next - now;
- if (ts > 0)
- sleep_ns(ts);
- }
- prog_deinit();
- deinit_app();
+ r = prog_main(mem);
free(mem);
- return 0;
-}
-
-void plat_present(
- int x,
- int y,
- int w,
- int h
-) {
- const Colour* src;
- Colour* dst;
- int i, j;
- int ex, ey;
- int s;
- ex = x + w;
- ey = y + h;
- dst = app.bp + x + y * app.w;
- src = app.fb + x + y * app.w;
- s = app.w - w;
- for (j = y; j < ey; j++) {
- for (i = x; i < ex; i++) {
- dst->r = src->b;
- dst->g = src->g;
- dst->b = src->r;
- dst->a = src->a;
- dst++;
- src++;
- }
- dst += s;
- src += s;
- }
- XPutImage(
- app.d,
- app.wi,
- app.gc,
- app.bb,
- x, y,
- x, y,
- w, h
- );
-}
-
-Colour* get_fb(void) {
- return app.fb;
-}
-
-int get_render_w(void) {
- return app.w;
-}
-
-int get_render_h(void) {
- return app.h;
-}
-
-int get_mouse_x(void) {
- return app.mx;
-}
-
-int get_mouse_y(void) {
- return app.my;
-}
-
-int get_mscroll_x(void) {
- return app.scrx;
-}
-
-int get_mscroll_y(void) {
- return app.scry;
-}
-
-int mbtn_pressed(MBtn btn) {
- return mheld_btns[btn];
-}
-
-int mbtn_just_pressed(MBtn btn) {
- return mpressed_btns[btn];
-}
-
-int mbtn_just_released(MBtn btn) {
- return mreleased_btns[btn];
+ return r;
}
#endif
-
diff --git a/plat.h b/plat.h
index 8b23eea..f001d70 100644
--- a/plat.h
+++ b/plat.h
@@ -1,44 +1,13 @@
#ifndef plat_h
+#define plat_h
-#include "render.h"
#include "error.h"
-int get_mouse_x();
-int get_mouse_y();
-
-typedef enum {
- mbtn_left,
- mbtn_middle,
- mbtn_right,
- mbtn_count
-} MBtn;
-int mbtn_pressed(MBtn btn);
-int mbtn_just_pressed(MBtn btn);
-int mbtn_just_released(MBtn btn);
-int get_mscroll_x(void);
-int get_mscroll_y(void);
-int get_mouse_x(void);
-int get_mouse_y(void);
-
-const char* get_text_input(int* len);
-
void print(const char* fmt, ...);
void print_err(const char* fmt, ...);
void print_war(const char* fmt, ...);
void pbreak(Error code);
-Colour* get_fb(void);
-
-unsigned long get_current_time();
-void sleep_ns(unsigned long ns);
-
-void plat_present(int x, int y, int w, int h);
-int get_render_w(void);
-int get_render_h(void);
-
-unsigned char* load_binary(const char* n, int* size);
-void free_file(void* p);
-
typedef void (*Dir_Iter)(void* uptr, const char* path);
void iter_dir(const char* path, Dir_Iter fn, void* u);
diff --git a/rcache.c b/rcache.c
deleted file mode 100644
index 9170f71..0000000
--- a/rcache.c
+++ /dev/null
@@ -1,467 +0,0 @@
-#include "error.h"
-#include "memory.h"
-#include "maths.h"
-#include "plat.h"
-#include "rcache.h"
-#include "render.h"
-
-#if rcache_enable
-unsigned* hgrid, * ohgrid, * hgrid1, * hgrid2;
-char* cmd_buf;
-int cmd_count;
-int rcache_cell_w, rcache_cell_h;
-
-void rc_init(void) {
- int i, e;
- rcache_cell_w = get_render_w() / rcache_gw;
- rcache_cell_h = get_render_h() / rcache_gh;
- cmd_buf = stack_alloc(rcache_cmd_buf_size);
- e = rcache_gw * rcache_gh * sizeof *hgrid1;
- hgrid1 = stack_alloc(e);
- hgrid2 = stack_alloc(e);
- hgrid = hgrid1;
- ohgrid = hgrid2;
- cmd_count = 0;
- e /= sizeof *hgrid1;
- for (i = 0; i < e; i++)
- hgrid1[i] = hgrid2[i] = 0;
-}
-
-RC_Cmd* rc_add_cmd(RC_Cmd* cmd) {
- int i;
- RC_Cmd* r;
- cmd->size = (cmd->size + 7) & -8;
-#ifdef DEBUG
- if (cmd_count + cmd->size >= rcache_cmd_buf_size) {
- print_err("Out of render command space.");
- pbreak(error_out_of_memory);
- return 0;
- }
-#endif
- r = (RC_Cmd*)&cmd_buf[cmd_count];
- for (i = 0; i < cmd->size; i++) {
- cmd_buf[cmd_count++] = ((char*)cmd)[i];
- }
- return r;
-}
-
-void rc_add_cmd_bmp(
- const Bitmap* bmp,
- int x,
- int y,
- const Rectangle* src
-) {
- RC_Cmd_Bmp cmd;
- cmd.cmd.type = rc_cmd_bmp;
- cmd.cmd.size = sizeof cmd;
- cmd.cmd.x = x;
- cmd.cmd.y = y;
- cmd.cmd.w = src->w;
- cmd.cmd.h = src->h;
- cmd.sx = src->x;
- cmd.sy = src->y;
- cmd.bmp = bmp;
- rc_add_cmd((RC_Cmd*)&cmd);
-}
-
-void rc_add_cmd_bmp_col(
- const Bitmap* bmp,
- int x,
- int y,
- const Rectangle* src,
- Colour col
-) {
- RC_Cmd_Bmp_Mod cmd;
- cmd.cmd.type = rc_cmd_bmp_mod;
- cmd.cmd.size = sizeof cmd;
- cmd.cmd.x = x;
- cmd.cmd.y = y;
- cmd.cmd.w = src->w;
- cmd.cmd.h = src->h;
- cmd.sx = src->x;
- cmd.sy = src->y;
- cmd.bmp = bmp;
- cmd.col = col;
- rc_add_cmd((RC_Cmd*)&cmd);
-}
-
-void rc_add_cmd_bmp_cp(
- const Bitmap* bmp,
- int x,
- int y,
- const Rectangle* src
-) {
- RC_Cmd_Bmp_Cp cmd;
- cmd.cmd.type = rc_cmd_bmp_cp;
- cmd.cmd.size = sizeof cmd;
- cmd.cmd.x = x;
- cmd.cmd.y = y;
- cmd.cmd.w = src->w;
- cmd.cmd.h = src->h;
- cmd.sx = src->x;
- cmd.sy = src->y;
- cmd.bmp = *bmp;
- rc_add_cmd((RC_Cmd*)&cmd);
-}
-
-void rc_add_cmd_bmp_cp_col(
- const Bitmap* bmp,
- int x,
- int y,
- const Rectangle* src,
- Colour col
-) {
- RC_Cmd_Bmp_Cp_Mod cmd;
- cmd.cmd.type = rc_cmd_bmp_cp_mod;
- cmd.cmd.size = sizeof cmd;
- cmd.cmd.x = x;
- cmd.cmd.y = y;
- cmd.cmd.w = src->w;
- cmd.cmd.h = src->h;
- cmd.sx = src->x;
- cmd.sy = src->y;
- cmd.bmp = *bmp;
- cmd.col = col;
- rc_add_cmd((RC_Cmd*)&cmd);
-}
-
-void rc_add_cmd_rfont_text(
- Font* font,
- int x,
- int y,
- const char* text
-) {
- RC_Cmd_RFont_Text cmd;
- RC_Cmd_RFont_Text* dc;
- Rectangle r;
- const char* c;
- char* d;
- r = text_rect(font, text);
- cmd.cmd.type = rc_cmd_rfont_text;
- cmd.cmd.x = x;
- cmd.cmd.y = y;
- cmd.cmd.w = r.w;
- cmd.cmd.h = r.h;
- cmd.font = font;
- for (c = text; *c; c++);
- cmd.cmd.size = sizeof cmd + (c - text) + 1;
- dc = (void*)rc_add_cmd((RC_Cmd*)&cmd);
- for (
- c = text, d = (char*)(dc + 1);
- *c;
- c++, d++
- ) *d = *c;
- *d = 0;
-}
-
-void rc_add_cmd_rfont_text_col(
- Font* font,
- int x,
- int y,
- const char* text,
- Colour col
-) {
- RC_Cmd_RFont_Text_Col cmd;
- RC_Cmd_RFont_Text_Col* dc;
- Rectangle r;
- const char* c;
- char* d;
- r = text_rect(font, text);
- cmd.cmd.type = rc_cmd_rfont_text_col;
- cmd.cmd.x = x;
- cmd.cmd.y = y;
- cmd.cmd.w = r.w;
- cmd.cmd.h = r.h;
- cmd.font = font;
- cmd.col = col;
- for (c = text; *c; c++);
- cmd.cmd.size = sizeof cmd + (c - text) + 1;
- dc = (void*)rc_add_cmd((RC_Cmd*)&cmd);
- for (
- c = text, d = (char*)(dc + 1);
- *c;
- c++, d++
- ) *d = *c;
- *d = 0;
-}
-
-void rc_add_cmd_clip(
- const Rectangle* rect
-) {
- RC_Cmd cmd;
- cmd.type = rc_cmd_set_clip;
- cmd.size = sizeof cmd;
- cmd.x = rect->x;
- cmd.y = rect->y;
- cmd.w = rect->w - rect->x;
- cmd.h = rect->h - rect->y;
- rc_add_cmd(&cmd);
-}
-
-void rc_add_cmd_reset_clip(void) {
- RC_Cmd cmd;
- cmd.type = rc_cmd_set_clip;
- cmd.size = sizeof cmd;
- cmd.x = 0;
- cmd.y = 0;
- cmd.w = get_render_w();
- cmd.h = get_render_h();
- rc_add_cmd(&cmd);
-}
-
-void rc_add_cmd_rect(
- const Rectangle* r,
- Colour col
-) {
- RC_Cmd_Rect cmd;
- cmd.cmd.type = rc_cmd_rect;
- cmd.cmd.size = sizeof cmd;
- cmd.cmd.x = r->x;
- cmd.cmd.y = r->y;
- cmd.cmd.w = r->w;
- cmd.cmd.h = r->h;
- cmd.col = col;
- rc_add_cmd((RC_Cmd*)&cmd);
-}
-
-static void hash(unsigned* hash, const void* data, int size) {
- const unsigned char *p = data;
- while (size--)
- *hash = (*hash ^ *p++) * 16777619;
-}
-
-void update_hgrid(unsigned* g) {
- int x, y, x1, y1, x2, y2, w;
- unsigned* d;
- RC_Cmd* cmd, * end;
- w = rcache_gw;
- x = rcache_gw * rcache_gh;
- for (y = 0; y < x; y++)
- g[y] = rcache_hash_seed;
- cmd = (RC_Cmd*)cmd_buf;
- end = (RC_Cmd*)(cmd_buf + cmd_count);
- for (
- ;
- cmd != end;
- cmd = (RC_Cmd*)((char*)cmd + cmd->size)
- ) {
- if (
- cmd->type == rc_cmd_set_clip ||
- cmd->type == rc_cmd_reset_clip
- ) continue;
- x1 = maxi(0, cmd->x / rcache_cell_w);
- y1 = maxi(0, cmd->y / rcache_cell_h);
- if (x1 >= rcache_gw) continue;
- if (y1 >= rcache_gh) continue;
- x2 = mini(
- (cmd->x + cmd->w) / rcache_cell_w,
- rcache_gw - 1
- );
- y2 = mini(
- (cmd->y + cmd->h) / rcache_cell_h,
- rcache_gh - 1
- );
- if (x2 < 0) continue;
- if (y2 < 0) continue;
- for (y = y1; y <= y2; y++)
- for (x = x1; x <= x2; x++) {
- d = &g[x + y * w];
- hash(d, cmd, cmd->size);
- }
- }
-}
-
-void rc_flush_rect(int x, int y, int w, int h) {
- RC_Cmd* cmd, * end;
- RC_Cmd_Bmp* bmpcmd;
- RC_Cmd_Bmp_Mod* bmpmcmd;
- RC_Cmd_Bmp_Cp* bmpcpcmd;
- RC_Cmd_Bmp_Cp_Mod* bmpmcpcmd;
- RC_Cmd_RFont_Text* txtrfcmd;
- RC_Cmd_RFont_Text_Col* txtrfccmd;
- Rectangle c, r;
- cmd = (RC_Cmd*)cmd_buf;
- end = (RC_Cmd*)(cmd_buf + cmd_count);
- int n, rw, rh;
- rw = get_render_w();
- rh = get_render_h();
- if (x > rw) return;
- if (y > rh) return;
- x = maxi(x, 0);
- y = maxi(y, 0);
- if ((n = x + w - rw) > 0)
- w -= n;
- if ((n = y + h - rh) > 0)
- h -= n;
- if (w <= 0) return;
- if (h <= 0) return;
- c.x = x;
- c.y = y;
- c.w = x + w;
- c.h = y + h;
- render_clip(&c);
- render_clear();
- while (cmd != end) {
- switch (cmd->type) {
- case rc_cmd_bmp:
- bmpcmd = (RC_Cmd_Bmp*)cmd;
- r.x = bmpcmd->sx;
- r.y = bmpcmd->sy;
- r.w = cmd->w;
- r.h = cmd->h;
- render_bitmap(
- bmpcmd->bmp,
- cmd->x,
- cmd->y,
- &r
- );
- break;
- case rc_cmd_bmp_mod:
- bmpmcmd = (RC_Cmd_Bmp_Mod*)cmd;
- r.x = bmpmcmd->sx;
- r.y = bmpmcmd->sy;
- r.w = cmd->w;
- r.h = cmd->h;
- render_bitmap_col(
- bmpmcmd->bmp,
- cmd->x,
- cmd->y,
- &r,
- bmpmcmd->col
- );
- break;
- case rc_cmd_bmp_cp:
- bmpcpcmd = (RC_Cmd_Bmp_Cp*)cmd;
- r.x = bmpcpcmd->sx;
- r.y = bmpcpcmd->sy;
- r.w = cmd->w;
- r.h = cmd->h;
- render_bitmap(
- &bmpcpcmd->bmp,
- cmd->x,
- cmd->y,
- &r
- );
- break;
- case rc_cmd_bmp_cp_mod:
- bmpmcpcmd = (RC_Cmd_Bmp_Cp_Mod*)cmd;
- r.x = bmpmcpcmd->sx;
- r.y = bmpmcpcmd->sy;
- r.w = cmd->w;
- r.h = cmd->h;
- render_bitmap_col(
- &bmpmcpcmd->bmp,
- cmd->x,
- cmd->y,
- &r,
- bmpmcpcmd->col
- );
- break;
- case rc_cmd_rfont_text:
- txtrfcmd = (RC_Cmd_RFont_Text*)cmd;
- rfont_text(
- txtrfcmd->font,
- cmd->x,
- cmd->y,
- (char*)(txtrfcmd + 1)
- );
- break;
- case rc_cmd_rfont_text_col:
- txtrfccmd = (RC_Cmd_RFont_Text_Col*)cmd;
- rfont_text_col(
- txtrfccmd->font,
- cmd->x,
- cmd->y,
- (char*)(txtrfccmd + 1),
- txtrfccmd->col
- );
- break;
- case rc_cmd_set_clip:
- r.x = cmd->x;
- r.y = cmd->y;
- r.w = cmd->w;
- r.h = cmd->h;
- r = rect_intersect(&c, &r);
- r.w += r.x;
- r.h += r.y;
- render_clip(&r);
- break;
- case rc_cmd_reset_clip:
- render_clip(&c);
- break;
- case rc_cmd_rect:
- r.x = cmd->x;
- r.y = cmd->y;
- r.w = cmd->w;
- r.h = cmd->h;
- render_rect(
- &r,
- ((RC_Cmd_Rect*)cmd)->col
- );
- break;
- }
- cmd = (RC_Cmd*)((char*)cmd + cmd->size);
- }
- plat_present(x, y, w, h);
- render_reset_clip();
-}
-
-void rc_flush(void) {
- int x, y, w, h, i;
- w = rcache_gw;
- h = rcache_gh;
- update_hgrid(hgrid);
- for (y = 0; y < h; y++)
- for (x = 0; x < w; x++) {
- i = x + y * w;
- if (hgrid[i] != ohgrid[i])
- rc_flush_rect(
- x * rcache_cell_w,
- y * rcache_cell_h,
- rcache_cell_w,
- rcache_cell_h
- );
- }
- cmd_count = 0;
- x = rcache_gw * rcache_gh;
- for (y = 0; y < x; y++)
- ohgrid[y] = hgrid[y];
- ohgrid = hgrid;
- hgrid = hgrid == hgrid1? hgrid2: hgrid1;
-}
-
-void rc_begin(void) {
- rcache_cell_w = (get_render_w() / rcache_gw) + 1;
- rcache_cell_h = (get_render_h() / rcache_gh) + 1;
-}
-
-void rc_invalidate(const Rectangle* r) {
- int x, y, x1, y1, x2, y2, w;
- x1 = maxi(0, r->x / rcache_cell_w);
- y1 = maxi(0, r->y / rcache_cell_h);
- x2 = mini(
- (r->x + r->w) / rcache_cell_w,
- rcache_gw - 1
- );
- y2 = mini(
- (r->y + r->h) / rcache_cell_h,
- rcache_gh - 1
- );
- w = rcache_gw;
- for (y = y1; y <= y2; y++)
- for (x = x1; x <= x2; x++) {
- ohgrid[x + y * w] = -1;
- }
-}
-#else
-
-void rc_init(void) {
- render_init();
-}
-
-void rc_flush(void) {
- plat_present(0, 0, get_render_w(), get_render_h());
- render_begin();
-}
-
-#endif
diff --git a/rcache.h b/rcache.h
deleted file mode 100644
index ff24f0c..0000000
--- a/rcache.h
+++ /dev/null
@@ -1,148 +0,0 @@
-#ifndef rcache_h
-#define rcache_h
-
-#include "render.h"
-
-#if rcache_enable
-typedef enum {
- rc_cmd_bmp,
- rc_cmd_bmp_mod,
- rc_cmd_bmp_cp,
- rc_cmd_bmp_cp_mod,
- rc_cmd_rfont_text,
- rc_cmd_rfont_text_col,
- rc_cmd_set_clip,
- rc_cmd_reset_clip,
- rc_cmd_rect
-} RC_Cmd_Type;
-
-typedef struct {
- RC_Cmd_Type type;
- int size;
- int x, y, w, h;
-} RC_Cmd;
-
-typedef struct {
- RC_Cmd cmd;
- const Bitmap* bmp;
- int sx, sy;
-} RC_Cmd_Bmp;
-
-typedef struct {
- RC_Cmd cmd;
- const Bitmap* bmp;
- int sx, sy;
- Colour col;
-} RC_Cmd_Bmp_Mod;
-
-typedef struct {
- RC_Cmd cmd;
- Bitmap bmp;
- int sx, sy;
-} RC_Cmd_Bmp_Cp;
-
-typedef struct {
- RC_Cmd cmd;
- Bitmap bmp;
- int sx, sy;
- Colour col;
-} RC_Cmd_Bmp_Cp_Mod;
-
-typedef struct {
- RC_Cmd cmd;
- Font* font;
-} RC_Cmd_RFont_Text;
-
-typedef struct {
- RC_Cmd cmd;
- Colour col;
- Font* font;
-} RC_Cmd_RFont_Text_Col;
-
-typedef struct {
- RC_Cmd cmd;
- Colour col;
-} RC_Cmd_Rect;
-
-typedef RC_Cmd RC_Cmd_Set_Clip;
-typedef RC_Cmd RC_Cmd_Reset_Clip;
-
-void rc_init(void);
-RC_Cmd* rc_add_cmd(RC_Cmd* cmd);
-void rc_add_cmd_bmp(
- const Bitmap* bmp,
- int x,
- int y,
- const Rectangle* src
-);
-void rc_add_cmd_bmp_col(
- const Bitmap* bmp,
- int x,
- int y,
- const Rectangle* src,
- Colour col
-);
-void rc_add_cmd_bmp_cp(
- const Bitmap* bmp,
- int x,
- int y,
- const Rectangle* src
-);
-void rc_add_cmd_bmp_cp_col(
- const Bitmap* bmp,
- int x,
- int y,
- const Rectangle* src,
- Colour col
-);
-void rc_add_cmd_rfont_text(
- Font* font,
- int x,
- int y,
- const char* text
-);
-void rc_add_cmd_rfont_text_col(
- Font* font,
- int x,
- int y,
- const char* text,
- Colour col
-);
-void rc_add_cmd_clip(
- const Rectangle* rect
-);
-void rc_add_cmd_reset_clip(void);
-void rc_add_cmd_rect(
- const Rectangle* r,
- Colour col
-);
-void rc_begin(void);
-void rc_flush(void);
-void rc_invalidate(const Rectangle* r);
-
-#else
-void rc_init(void);
-#define rc_add_cmd_bmp(bmp, x, y, src) \
- render_bitmap(bmp, x, y, src)
-#define rc_add_cmd_bmp_col(bmp, x, y, src, col) \
- render_bitmap_col(bmp, x, y, src, col)
-#define rc_add_cmd_bmp_cp(bmp, x, y, src) \
- render_bitmap(bmp, x, y, src)
-#define rc_add_cmd_bmp_cp_col(bmp, x, y, src, col) \
- render_bitmap_col(bmp, x, y, src, col)
-#define rc_add_cmd_rfont_text(font, x, y, text) \
- rfont_text(font, x, y, text)
-#define rc_add_cmd_rfont_text_col(font, x, y, text, col) \
- rfont_text_col(font, x, y, text, col)
-#define rc_add_cmd_clip(rect) \
- render_clip(rect)
-#define rc_add_cmd_reset_clip() \
- render_reset_clip()
-#define rc_add_cmd_rect(r, col) \
- render_rect(r, col)
-#define rc_invalidate(r)
-#define rc_begin()
-void rc_flush(void);
-#endif
-
-#endif
diff --git a/rect.c b/rect.c
deleted file mode 100644
index bcc95cd..0000000
--- a/rect.c
+++ /dev/null
@@ -1,96 +0,0 @@
-#include "maths.h"
-#include "rect.h"
-
-Rectangle make_rect(int x, int y, int w, int h) {
- Rectangle r;
- r.x = x;
- r.y = y;
- r.w = w;
- r.h = h;
- return r;
-}
-
-int rects_overlap(const Rectangle* a, const Rectangle* b) {
- return
- a->x + a->w > b->x &&
- a->y + a->h > b->y &&
- a->x < b->x + b->w &&
- a->y < b->y + b->h;
-}
-
-int rects_overlap2(
- int x0,
- int y0,
- int w0,
- int h0,
- int x1,
- int y1,
- int w1,
- int h1
-) {
- return
- x0 + w0 > x1 &&
- y0 + h0 > y1 &&
- x0 < x1 + w1 &&
- y0 < y1 + h1;
-}
-
-int point_rect_overlap(
- const Rectangle* r,
- int px,
- int py
-) {
- return
- px >= r->x &&
- py >= r->y &&
- px <= r->x + r->w &&
- py <= r->y + r->h;
-}
-
-int point_rect_overlap2(
- int x,
- int y,
- int w,
- int h,
- int px,
- int py
-) {
- return
- px > x &&
- py > y &&
- px < x + w &&
- py < y + h;
-}
-
-Rectangle rect_intersect(
- const Rectangle* a,
- const Rectangle* b
-) {
- int x1, y1, x2, y2;
- Rectangle r;
- x1 = maxi(a->x, b->x);
- y1 = maxi(a->y, b->y);
- x2 = mini(a->x + a->w, b->x + b->w);
- y2 = mini(a->y + a->h, b->y + b->h);
- r.x = x1;
- r.y = y1;
- r.w = maxi(0, x2 - x1);
- r.h = maxi(0, y2 - y1);
- return r;
-}
-
-Rectangle* rect_merge(
- Rectangle* d,
- const Rectangle* r
-) {
- int x1, y1, x2, y2;
- x1 = mini(d->x, r->x);
- y1 = mini(d->y, r->y);
- x2 = maxi(d->x + d->w, r->x + r->w);
- y2 = maxi(d->y + d->h, r->y + r->h);
- d->x = x1;
- d->y = y1;
- d->w = x2 - x1;
- d->h = y2 - y1;
- return d;
-}
diff --git a/rect.h b/rect.h
deleted file mode 100644
index 4d6a88f..0000000
--- a/rect.h
+++ /dev/null
@@ -1,43 +0,0 @@
-#ifndef rect_h
-#define rect_h
-
-typedef struct {
- int x, y, w, h;
-} Rectangle;
-
-Rectangle make_rect(int x, int y, int w, int h);
-
-int rects_overlap(const Rectangle* a, const Rectangle* b);
-int rects_overlap2(
- int x0,
- int y0,
- int w0,
- int h0,
- int x1,
- int y1,
- int w1,
- int h1
-);
-int point_rect_overlap(
- const Rectangle* r,
- int px,
- int py
-);
-int point_rect_overlap2(
- int x,
- int y,
- int w,
- int h,
- int px,
- int py
-);
-Rectangle rect_intersect(
- const Rectangle* a,
- const Rectangle* b
-);
-Rectangle* rect_merge(
- Rectangle* d,
- const Rectangle* r
-);
-
-#endif
diff --git a/render.c b/render.c
deleted file mode 100644
index e291e7d..0000000
--- a/render.c
+++ /dev/null
@@ -1,380 +0,0 @@
-#include "plat.h"
-#include "maths.h"
-#include "render.h"
-
-static struct {
- Rectangle clip;
-} renderer;
-
-Colour make_colour(unsigned rgb, unsigned char a) {
- Colour r;
- r.r = (unsigned char)(rgb >> 16);
- r.g = (unsigned char)(rgb >> 8);
- r.b = (unsigned char)rgb;
- r.a = a;
- return r;
-}
-
-Colour make_black() {
- Colour r = { 0, 0, 0, 255 };
- return r;
-}
-
-Colour make_white() {
- return make_colour(0xffffff, 255);
-}
-
-void init_bitmap(
- Bitmap* bitmap,
- Colour* pixels,
- int w,
- int h
-) {
- bitmap->pixels = pixels;
- bitmap->w = w;
- bitmap->h = h;
-}
-
-void render_init(void) {
- int i, e;
- Colour b, * p;
- b = make_black();
- p = get_fb();
- e = get_render_w() * get_render_h();
- for (i = 0; i < e; i++)
- p[i] = b;
-}
-
-void render_begin(void) {
- int i, e;
- Colour b, * p;
- b = make_black();
- p = get_fb();
- e = get_render_w() * get_render_h();
- for (i = 0; i < e; i++)
- p[i] = b;
- render_reset_clip();
-}
-
-void render_clear(void) {
- render_clear_col(make_black());
-}
-
-void render_clear_col(Colour col) {
- Colour* d;
- int ox, x, y, ex, ey, w;
- d = get_fb();
- x = renderer.clip.x;
- y = renderer.clip.y;
- ex = renderer.clip.w;
- ey = renderer.clip.h;
- ox = x;
- w = get_render_w();
- for (; y < ey; y++)
- for (x = ox; x < ex; x++)
- d[x + y * w] = col;
-}
-
-void render_clip(const Rectangle* rect) {
- renderer.clip = *rect;
- renderer.clip.x = maxi(renderer.clip.x, 0);
- renderer.clip.y = maxi(renderer.clip.y, 0);
- renderer.clip.w = mini(
- renderer.clip.w,
- get_render_w()
- );
- renderer.clip.h = mini(
- renderer.clip.h,
- get_render_h()
- );
-}
-
-void render_reset_clip(void) {
- renderer.clip.x = 0;
- renderer.clip.y = 0;
- renderer.clip.w = get_render_w();
- renderer.clip.h = get_render_h();
-}
-
-Colour* get_render_pixels(void) {
- return get_fb();
-}
-
-Colour blend(Colour dst, Colour src) {
- int ima;
-
- ima = 0xff - src.a;
- dst.r = (unsigned char)(((src.r * src.a) + (dst.r * ima)) >> 8);
- dst.g = (unsigned char)(((src.g * src.a) + (dst.g * ima)) >> 8);
- dst.b = (unsigned char)(((src.b * src.a) + (dst.b * ima)) >> 8);
-
- return dst;
-}
-
-Colour blend_mod(Colour dst, Colour src, Colour mod) {
- int ima;
-
- src.a = (src.a * mod.a) >> 8;
- ima = 0xff - src.a;
- dst.r = (unsigned char)(((src.r * mod.r * src.a) >> 16) + ((dst.r * ima) >> 8));
- dst.g = (unsigned char)(((src.g * mod.g * src.a) >> 16) + ((dst.g * ima) >> 8));
- dst.b = (unsigned char)(((src.b * mod.b * src.a) >> 16) + ((dst.b * ima) >> 8));
-
- return dst;
-}
-
-#define blit_vars(t_) \
- int i, j, stride, sstride, n; \
- Colour* dst; \
- const t_* src; \
- Rectangle sub;
-#define blit( \
- src_, \
- dst_, \
- pitch_, \
- clip_, \
- src_w_, \
- src_h_, \
- expr_ \
-) \
- sub = *rect; \
- if (sub.w <= 0) { goto end; } \
- if (sub.h <= 0) { goto end; } \
- if (sub.w > (src_w_)) { goto end; } \
- if (sub.h > (src_h_)) { goto end; } \
- if ((n = (clip_).x - x) > 0) { \
- sub.w -= n; \
- sub.x += n; \
- x += n; \
- } \
- if ((n = (clip_).y - y) > 0) { \
- sub.h -= n; \
- sub.y += n; \
- y += n; \
- } \
- if ((n = x + sub.w - (clip_).w) > 0) { \
- sub.w -= n; \
- } \
- if ((n = y + sub.h - (clip_).h) > 0) { \
- sub.h -= n; \
- } \
- if (sub.w <= 0) { goto end; } \
- if (sub.h <= 0) { goto end; } \
- dst = (dst_) + (x + y * (pitch_)); \
- src = (src_) + (sub.x + sub.y * (src_w_)); \
- stride = (pitch_) - sub.w; \
- sstride = (src_w_) - sub.w; \
- for (i = 0; i < sub.h; i++) { \
- for (j = 0; j < sub.w; j++) { \
- expr_; \
- dst++; \
- src++; \
- } \
- dst += stride; \
- src += sstride; \
- } \
- end:
-
-#define blit_rect_vars \
- int x1, y1, x2, y2, dr, j, i; \
- Colour* dst;
-#define blit_rect(dst_, pitch_, clip_) \
- x1 = rect->x < (clip_).x ? (clip_).x : rect->x; \
- y1 = rect->y < (clip_).y ? (clip_).y : rect->y; \
- x2 = rect->x + rect->w; \
- y2 = rect->y + rect->h; \
- x2 = x2 > (clip_).w? (clip_).w: x2; \
- y2 = y2 > (clip_).h? (clip_).h: y2; \
- dst = dst_; \
- dst += x1 + y1 * pitch_; \
- dr = pitch_ - (x2 - x1); \
- for (j = y1; j < y2; j++) { \
- for (i = x1; i < x2; i++) { \
- *dst = blend(*dst, colour); \
- dst++; \
- } \
- dst += dr; \
- }
-
-void render_bitmap(
- const Bitmap* bitmap,
- int x,
- int y,
- const Rectangle* rect
-) {
- blit_vars(Colour)
- int renderer_w;
- Colour* renderer_pixels;
- renderer_w = get_render_w();
- renderer_pixels = get_fb();
- blit(
- bitmap->pixels,
- renderer_pixels,
- renderer_w,
- renderer.clip,
- bitmap->w,
- bitmap->h,
- *dst = blend(*dst, *src)
- );
-}
-
-void render_bitmap_col(
- const Bitmap* bitmap,
- int x,
- int y,
- const Rectangle* rect,
- Colour colour
-) {
- blit_vars(Colour)
- int renderer_w;
- Colour* renderer_pixels;
- renderer_w = get_render_w();
- renderer_pixels = get_fb();
- blit(
- bitmap->pixels,
- renderer_pixels,
- renderer_w,
- renderer.clip,
- bitmap->w,
- bitmap->h,
- *dst = blend_mod(*dst, *src, colour)
- );
-}
-
-void render_mask(
- const unsigned char* pixels,
- int x,
- int y,
- int w,
- int h,
- const Rectangle* rect,
- Colour colour
-) {
- blit_vars(unsigned char)
- int renderer_w;
- Colour c;
- Colour* renderer_pixels;
- renderer_w = get_render_w();
- renderer_pixels = get_fb();
- c = colour;
- blit(
- pixels,
- renderer_pixels,
- renderer_w,
- renderer.clip,
- w,
- h,
- {
- c.a = colour.a * *src;
- *dst = blend(*dst, c);
- }
- );
-}
-
-void render_rect(
- const Rectangle* rect,
- Colour colour
-) {
- blit_rect_vars
- int renderer_w;
- Colour* renderer_pixels;
- renderer_w = get_render_w();
- renderer_pixels = get_fb();
- blit_rect(
- renderer_pixels,
- renderer_w,
- renderer.clip
- );
-}
-
-void rcopy(
- Bitmap* to,
- const Bitmap* from,
- int x,
- int y,
- const Rectangle* rect
-) {
- Rectangle clip;
- blit_vars(Colour);
- clip.x = 0;
- clip.y = 0;
- clip.w = to->w;
- clip.h = to->h;
- blit(
- from->pixels,
- to->pixels,
- to->w,
- clip,
- from->w,
- from->h,
- *dst = blend(*dst, *src)
- );
-}
-
-void rcopy_col(
- Bitmap* to,
- const Bitmap* from,
- int x,
- int y,
- const Rectangle* rect,
- Colour colour
-) {
- Rectangle clip;
- blit_vars(Colour)
- clip.x = 0;
- clip.y = 0;
- clip.w = to->w;
- clip.h = to->h;
- blit(
- from->pixels,
- to->pixels,
- to->w,
- clip,
- from->w,
- from->h,
- *dst = blend_mod(*dst, *src, colour);
- );
-}
-
-void rcopy_ac(
- Bitmap* to,
- const Bitmap* from,
- int x,
- int y,
- const Rectangle* rect,
- unsigned char t
-) {
- Rectangle clip;
- blit_vars(Colour)
- clip.x = 0;
- clip.y = 0;
- clip.w = to->w;
- clip.h = to->h;
- blit(
- from->pixels,
- to->pixels,
- to->w,
- clip,
- from->w,
- from->h,
- *dst = src->a > t ? *src : *dst;
- );
-}
-
-void rcopy_rect(
- Bitmap* to,
- const Rectangle* rect,
- Colour colour
-) {
- Rectangle clip;
- blit_rect_vars
- clip.x = 0;
- clip.y = 0;
- clip.w = to->w;
- clip.h = to->h;
- blit_rect(
- to->pixels,
- to->w,
- clip
- );
-}
diff --git a/render.h b/render.h
deleted file mode 100644
index 62044a0..0000000
--- a/render.h
+++ /dev/null
@@ -1,140 +0,0 @@
-#ifndef render_h
-#define render_h
-
-#include "config.h"
-#include "rect.h"
-#include "memory.h"
-
-typedef struct {
- unsigned char r, g, b, a;
-} Colour;
-
-Colour make_colour(unsigned rgb, unsigned char a);
-Colour make_black();
-Colour make_white();
-
-typedef struct Bitmap {
- Colour* pixels;
- int w, h;
-} Bitmap;
-
-void init_bitmap(
- Bitmap* bitmap,
- Colour* pixels,
- int w,
- int h
-);
-
-#define max_glyphset 256
-
-struct Font;
-typedef struct Font Font;
-
-int font_height(Font* f);
-
-void get_font_rect(
- const Font* font,
- Rectangle* dst,
- char c
-);
-
-Font* new_font(
- Heap* h,
- const unsigned char* raw,
- int size
-);
-Rectangle text_rect(Font* font, const char* text);
-
-void rfont_text(
- Font* font,
- int x,
- int y,
- const char* text
-);
-void rfont_text_col(
- Font* font,
- int x,
- int y,
- const char* text,
- Colour colour
-);
-
-void render_init(void);
-
-void render_begin(void);
-void render_clear(void);
-void render_clear_col(Colour col);
-void render_clip(const Rectangle* rect);
-void render_reset_clip(void);
-
-Colour blend(Colour dst, Colour src);
-Colour blend_mod(Colour dst, Colour src, Colour mod);
-
-Colour* get_render_pixels(void);
-
-extern int sprite_camera_x;
-extern int sprite_camera_y;
-
-void render_bitmap(
- const Bitmap* bitmap,
- int x,
- int y,
- const Rectangle* rect
-);
-
-void render_bitmap_col(
- const Bitmap* bitmap,
- int x,
- int y,
- const Rectangle* rect,
- Colour colour
-);
-
-void render_rect(
- const Rectangle* rect,
- Colour colour
-);
-
-void render_mask(
- const unsigned char* pixels,
- int x,
- int y,
- int w,
- int h,
- const Rectangle* rect,
- Colour colour
-);
-
-void rcopy(
- Bitmap* dst,
- const Bitmap* src,
- int x,
- int y,
- const Rectangle* rect
-);
-
-void rcopy_col(
- Bitmap* dst,
- const Bitmap* src,
- int x,
- int y,
- const Rectangle* rect,
- Colour colour
-);
-
-void rcopy_ac(
- Bitmap* dst,
- const Bitmap* src,
- int x,
- int y,
- const Rectangle* rect,
- unsigned char t
-);
-
-void rcopy_rect(
- Bitmap* dst,
- const Rectangle* rect,
- Colour colour
-);
-
-#endif
diff --git a/stb_image.h b/stb_image.h
index a632d54..9eedabe 100644
--- a/stb_image.h
+++ b/stb_image.h
@@ -1,4 +1,4 @@
-/* stb_image - v2.29 - public domain image loader - http://nothings.org/stb
+/* stb_image - v2.30 - public domain image loader - http://nothings.org/stb
no warranty implied; use at your own risk
Do this:
@@ -48,6 +48,7 @@ LICENSE
RECENT REVISION HISTORY:
+ 2.30 (2024-05-31) avoid erroneous gcc warning
2.29 (2023-05-xx) optimizations
2.28 (2023-01-29) many error fixes, security errors, just tons of stuff
2.27 (2021-07-11) document stbi_info better, 16-bit PNM support, bug fixes
@@ -5159,9 +5160,11 @@ static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp)
// non-paletted with tRNS = constant alpha. if header-scanning, we can stop now.
if (scan == STBI__SCAN_header) { ++s->img_n; return 1; }
if (z->depth == 16) {
- for (k = 0; k < s->img_n; ++k) tc16[k] = (stbi__uint16)stbi__get16be(s); // copy the values as-is
+ for (k = 0; k < s->img_n && k < 3; ++k) // extra loop test to suppress false GCC warning
+ tc16[k] = (stbi__uint16)stbi__get16be(s); // copy the values as-is
} else {
- 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
+ for (k = 0; k < s->img_n && k < 3; ++k)
+ tc[k] = (stbi_uc)(stbi__get16be(s) & 255) * stbi__depth_scale_table[z->depth]; // non 8-bit images will be larger
}
}
break;
diff --git a/stb_rect_pack.h b/stb_rect_pack.h
deleted file mode 100644
index 6a633ce..0000000
--- a/stb_rect_pack.h
+++ /dev/null
@@ -1,623 +0,0 @@
-// stb_rect_pack.h - v1.01 - public domain - rectangle packing
-// Sean Barrett 2014
-//
-// Useful for e.g. packing rectangular textures into an atlas.
-// Does not do rotation.
-//
-// Before #including,
-//
-// #define STB_RECT_PACK_IMPLEMENTATION
-//
-// in the file that you want to have the implementation.
-//
-// Not necessarily the awesomest packing method, but better than
-// the totally naive one in stb_truetype (which is primarily what
-// this is meant to replace).
-//
-// Has only had a few tests run, may have issues.
-//
-// More docs to come.
-//
-// No memory allocations; uses qsort() and assert() from stdlib.
-// Can override those by defining STBRP_SORT and STBRP_ASSERT.
-//
-// This library currently uses the Skyline Bottom-Left algorithm.
-//
-// Please note: better rectangle packers are welcome! Please
-// implement them to the same API, but with a different init
-// function.
-//
-// Credits
-//
-// Library
-// Sean Barrett
-// Minor features
-// Martins Mozeiko
-// github:IntellectualKitty
-//
-// Bugfixes / warning fixes
-// Jeremy Jaussaud
-// Fabian Giesen
-//
-// Version history:
-//
-// 1.01 (2021-07-11) always use large rect mode, expose STBRP__MAXVAL in public section
-// 1.00 (2019-02-25) avoid small space waste; gracefully fail too-wide rectangles
-// 0.99 (2019-02-07) warning fixes
-// 0.11 (2017-03-03) return packing success/fail result
-// 0.10 (2016-10-25) remove cast-away-const to avoid warnings
-// 0.09 (2016-08-27) fix compiler warnings
-// 0.08 (2015-09-13) really fix bug with empty rects (w=0 or h=0)
-// 0.07 (2015-09-13) fix bug with empty rects (w=0 or h=0)
-// 0.06 (2015-04-15) added STBRP_SORT to allow replacing qsort
-// 0.05: added STBRP_ASSERT to allow replacing assert
-// 0.04: fixed minor bug in STBRP_LARGE_RECTS support
-// 0.01: initial release
-//
-// LICENSE
-//
-// See end of file for license information.
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// INCLUDE SECTION
-//
-
-#ifndef STB_INCLUDE_STB_RECT_PACK_H
-#define STB_INCLUDE_STB_RECT_PACK_H
-
-#define STB_RECT_PACK_VERSION 1
-
-#ifdef STBRP_STATIC
-#define STBRP_DEF static
-#else
-#define STBRP_DEF extern
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct stbrp_context stbrp_context;
-typedef struct stbrp_node stbrp_node;
-typedef struct stbrp_rect stbrp_rect;
-
-typedef int stbrp_coord;
-
-#define STBRP__MAXVAL 0x7fffffff
-// Mostly for internal use, but this is the maximum supported coordinate value.
-
-STBRP_DEF int stbrp_pack_rects (stbrp_context *context, stbrp_rect *rects, int num_rects);
-// Assign packed locations to rectangles. The rectangles are of type
-// 'stbrp_rect' defined below, stored in the array 'rects', and there
-// are 'num_rects' many of them.
-//
-// Rectangles which are successfully packed have the 'was_packed' flag
-// set to a non-zero value and 'x' and 'y' store the minimum location
-// on each axis (i.e. bottom-left in cartesian coordinates, top-left
-// if you imagine y increasing downwards). Rectangles which do not fit
-// have the 'was_packed' flag set to 0.
-//
-// You should not try to access the 'rects' array from another thread
-// while this function is running, as the function temporarily reorders
-// the array while it executes.
-//
-// To pack into another rectangle, you need to call stbrp_init_target
-// again. To continue packing into the same rectangle, you can call
-// this function again. Calling this multiple times with multiple rect
-// arrays will probably produce worse packing results than calling it
-// a single time with the full rectangle array, but the option is
-// available.
-//
-// The function returns 1 if all of the rectangles were successfully
-// packed and 0 otherwise.
-
-struct stbrp_rect
-{
- // reserved for your use:
- int id;
-
- // input:
- stbrp_coord w, h;
-
- // output:
- stbrp_coord x, y;
- int was_packed; // non-zero if valid packing
-
-}; // 16 bytes, nominally
-
-
-STBRP_DEF void stbrp_init_target (stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes);
-// Initialize a rectangle packer to:
-// pack a rectangle that is 'width' by 'height' in dimensions
-// using temporary storage provided by the array 'nodes', which is 'num_nodes' long
-//
-// You must call this function every time you start packing into a new target.
-//
-// There is no "shutdown" function. The 'nodes' memory must stay valid for
-// the following stbrp_pack_rects() call (or calls), but can be freed after
-// the call (or calls) finish.
-//
-// Note: to guarantee best results, either:
-// 1. make sure 'num_nodes' >= 'width'
-// or 2. call stbrp_allow_out_of_mem() defined below with 'allow_out_of_mem = 1'
-//
-// If you don't do either of the above things, widths will be quantized to multiples
-// of small integers to guarantee the algorithm doesn't run out of temporary storage.
-//
-// If you do #2, then the non-quantized algorithm will be used, but the algorithm
-// may run out of temporary storage and be unable to pack some rectangles.
-
-STBRP_DEF void stbrp_setup_allow_out_of_mem (stbrp_context *context, int allow_out_of_mem);
-// Optionally call this function after init but before doing any packing to
-// change the handling of the out-of-temp-memory scenario, described above.
-// If you call init again, this will be reset to the default (false).
-
-
-STBRP_DEF void stbrp_setup_heuristic (stbrp_context *context, int heuristic);
-// Optionally select which packing heuristic the library should use. Different
-// heuristics will produce better/worse results for different data sets.
-// If you call init again, this will be reset to the default.
-
-enum
-{
- STBRP_HEURISTIC_Skyline_default=0,
- STBRP_HEURISTIC_Skyline_BL_sortHeight = STBRP_HEURISTIC_Skyline_default,
- STBRP_HEURISTIC_Skyline_BF_sortHeight
-};
-
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// the details of the following structures don't matter to you, but they must
-// be visible so you can handle the memory allocations for them
-
-struct stbrp_node
-{
- stbrp_coord x,y;
- stbrp_node *next;
-};
-
-struct stbrp_context
-{
- int width;
- int height;
- int align;
- int init_mode;
- int heuristic;
- int num_nodes;
- stbrp_node *active_head;
- stbrp_node *free_head;
- stbrp_node extra[2]; // we allocate two extra nodes so optimal user-node-count is 'width' not 'width+2'
-};
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// IMPLEMENTATION SECTION
-//
-
-#ifdef STB_RECT_PACK_IMPLEMENTATION
-#ifndef STBRP_SORT
-#include <stdlib.h>
-#define STBRP_SORT qsort
-#endif
-
-#ifndef STBRP_ASSERT
-#include <assert.h>
-#define STBRP_ASSERT assert
-#endif
-
-#ifdef _MSC_VER
-#define STBRP__NOTUSED(v) (void)(v)
-#define STBRP__CDECL __cdecl
-#else
-#define STBRP__NOTUSED(v) (void)sizeof(v)
-#define STBRP__CDECL
-#endif
-
-enum
-{
- STBRP__INIT_skyline = 1
-};
-
-STBRP_DEF void stbrp_setup_heuristic(stbrp_context *context, int heuristic)
-{
- switch (context->init_mode) {
- case STBRP__INIT_skyline:
- STBRP_ASSERT(heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight || heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight);
- context->heuristic = heuristic;
- break;
- default:
- STBRP_ASSERT(0);
- }
-}
-
-STBRP_DEF void stbrp_setup_allow_out_of_mem(stbrp_context *context, int allow_out_of_mem)
-{
- if (allow_out_of_mem)
- // if it's ok to run out of memory, then don't bother aligning them;
- // this gives better packing, but may fail due to OOM (even though
- // the rectangles easily fit). @TODO a smarter approach would be to only
- // quantize once we've hit OOM, then we could get rid of this parameter.
- context->align = 1;
- else {
- // if it's not ok to run out of memory, then quantize the widths
- // so that num_nodes is always enough nodes.
- //
- // I.e. num_nodes * align >= width
- // align >= width / num_nodes
- // align = ceil(width/num_nodes)
-
- context->align = (context->width + context->num_nodes-1) / context->num_nodes;
- }
-}
-
-STBRP_DEF void stbrp_init_target(stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes)
-{
- int i;
-
- for (i=0; i < num_nodes-1; ++i)
- nodes[i].next = &nodes[i+1];
- nodes[i].next = NULL;
- context->init_mode = STBRP__INIT_skyline;
- context->heuristic = STBRP_HEURISTIC_Skyline_default;
- context->free_head = &nodes[0];
- context->active_head = &context->extra[0];
- context->width = width;
- context->height = height;
- context->num_nodes = num_nodes;
- stbrp_setup_allow_out_of_mem(context, 0);
-
- // node 0 is the full width, node 1 is the sentinel (lets us not store width explicitly)
- context->extra[0].x = 0;
- context->extra[0].y = 0;
- context->extra[0].next = &context->extra[1];
- context->extra[1].x = (stbrp_coord) width;
- context->extra[1].y = (1<<30);
- context->extra[1].next = NULL;
-}
-
-// find minimum y position if it starts at x1
-static int stbrp__skyline_find_min_y(stbrp_context *c, stbrp_node *first, int x0, int width, int *pwaste)
-{
- stbrp_node *node = first;
- int x1 = x0 + width;
- int min_y, visited_width, waste_area;
-
- STBRP__NOTUSED(c);
-
- STBRP_ASSERT(first->x <= x0);
-
- #if 0
- // skip in case we're past the node
- while (node->next->x <= x0)
- ++node;
- #else
- STBRP_ASSERT(node->next->x > x0); // we ended up handling this in the caller for efficiency
- #endif
-
- STBRP_ASSERT(node->x <= x0);
-
- min_y = 0;
- waste_area = 0;
- visited_width = 0;
- while (node->x < x1) {
- if (node->y > min_y) {
- // raise min_y higher.
- // we've accounted for all waste up to min_y,
- // but we'll now add more waste for everything we've visted
- waste_area += visited_width * (node->y - min_y);
- min_y = node->y;
- // the first time through, visited_width might be reduced
- if (node->x < x0)
- visited_width += node->next->x - x0;
- else
- visited_width += node->next->x - node->x;
- } else {
- // add waste area
- int under_width = node->next->x - node->x;
- if (under_width + visited_width > width)
- under_width = width - visited_width;
- waste_area += under_width * (min_y - node->y);
- visited_width += under_width;
- }
- node = node->next;
- }
-
- *pwaste = waste_area;
- return min_y;
-}
-
-typedef struct
-{
- int x,y;
- stbrp_node **prev_link;
-} stbrp__findresult;
-
-static stbrp__findresult stbrp__skyline_find_best_pos(stbrp_context *c, int width, int height)
-{
- int best_waste = (1<<30), best_x, best_y = (1 << 30);
- stbrp__findresult fr;
- stbrp_node **prev, *node, *tail, **best = NULL;
-
- // align to multiple of c->align
- width = (width + c->align - 1);
- width -= width % c->align;
- STBRP_ASSERT(width % c->align == 0);
-
- // if it can't possibly fit, bail immediately
- if (width > c->width || height > c->height) {
- fr.prev_link = NULL;
- fr.x = fr.y = 0;
- return fr;
- }
-
- node = c->active_head;
- prev = &c->active_head;
- while (node->x + width <= c->width) {
- int y,waste;
- y = stbrp__skyline_find_min_y(c, node, node->x, width, &waste);
- if (c->heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight) { // actually just want to test BL
- // bottom left
- if (y < best_y) {
- best_y = y;
- best = prev;
- }
- } else {
- // best-fit
- if (y + height <= c->height) {
- // can only use it if it first vertically
- if (y < best_y || (y == best_y && waste < best_waste)) {
- best_y = y;
- best_waste = waste;
- best = prev;
- }
- }
- }
- prev = &node->next;
- node = node->next;
- }
-
- best_x = (best == NULL) ? 0 : (*best)->x;
-
- // if doing best-fit (BF), we also have to try aligning right edge to each node position
- //
- // e.g, if fitting
- //
- // ____________________
- // |____________________|
- //
- // into
- //
- // | |
- // | ____________|
- // |____________|
- //
- // then right-aligned reduces waste, but bottom-left BL is always chooses left-aligned
- //
- // This makes BF take about 2x the time
-
- if (c->heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight) {
- tail = c->active_head;
- node = c->active_head;
- prev = &c->active_head;
- // find first node that's admissible
- while (tail->x < width)
- tail = tail->next;
- while (tail) {
- int xpos = tail->x - width;
- int y,waste;
- STBRP_ASSERT(xpos >= 0);
- // find the left position that matches this
- while (node->next->x <= xpos) {
- prev = &node->next;
- node = node->next;
- }
- STBRP_ASSERT(node->next->x > xpos && node->x <= xpos);
- y = stbrp__skyline_find_min_y(c, node, xpos, width, &waste);
- if (y + height <= c->height) {
- if (y <= best_y) {
- if (y < best_y || waste < best_waste || (waste==best_waste && xpos < best_x)) {
- best_x = xpos;
- STBRP_ASSERT(y <= best_y);
- best_y = y;
- best_waste = waste;
- best = prev;
- }
- }
- }
- tail = tail->next;
- }
- }
-
- fr.prev_link = best;
- fr.x = best_x;
- fr.y = best_y;
- return fr;
-}
-
-static stbrp__findresult stbrp__skyline_pack_rectangle(stbrp_context *context, int width, int height)
-{
- // find best position according to heuristic
- stbrp__findresult res = stbrp__skyline_find_best_pos(context, width, height);
- stbrp_node *node, *cur;
-
- // bail if:
- // 1. it failed
- // 2. the best node doesn't fit (we don't always check this)
- // 3. we're out of memory
- if (res.prev_link == NULL || res.y + height > context->height || context->free_head == NULL) {
- res.prev_link = NULL;
- return res;
- }
-
- // on success, create new node
- node = context->free_head;
- node->x = (stbrp_coord) res.x;
- node->y = (stbrp_coord) (res.y + height);
-
- context->free_head = node->next;
-
- // insert the new node into the right starting point, and
- // let 'cur' point to the remaining nodes needing to be
- // stiched back in
-
- cur = *res.prev_link;
- if (cur->x < res.x) {
- // preserve the existing one, so start testing with the next one
- stbrp_node *next = cur->next;
- cur->next = node;
- cur = next;
- } else {
- *res.prev_link = node;
- }
-
- // from here, traverse cur and free the nodes, until we get to one
- // that shouldn't be freed
- while (cur->next && cur->next->x <= res.x + width) {
- stbrp_node *next = cur->next;
- // move the current node to the free list
- cur->next = context->free_head;
- context->free_head = cur;
- cur = next;
- }
-
- // stitch the list back in
- node->next = cur;
-
- if (cur->x < res.x + width)
- cur->x = (stbrp_coord) (res.x + width);
-
-#ifdef _DEBUG
- cur = context->active_head;
- while (cur->x < context->width) {
- STBRP_ASSERT(cur->x < cur->next->x);
- cur = cur->next;
- }
- STBRP_ASSERT(cur->next == NULL);
-
- {
- int count=0;
- cur = context->active_head;
- while (cur) {
- cur = cur->next;
- ++count;
- }
- cur = context->free_head;
- while (cur) {
- cur = cur->next;
- ++count;
- }
- STBRP_ASSERT(count == context->num_nodes+2);
- }
-#endif
-
- return res;
-}
-
-static int STBRP__CDECL rect_height_compare(const void *a, const void *b)
-{
- const stbrp_rect *p = (const stbrp_rect *) a;
- const stbrp_rect *q = (const stbrp_rect *) b;
- if (p->h > q->h)
- return -1;
- if (p->h < q->h)
- return 1;
- return (p->w > q->w) ? -1 : (p->w < q->w);
-}
-
-static int STBRP__CDECL rect_original_order(const void *a, const void *b)
-{
- const stbrp_rect *p = (const stbrp_rect *) a;
- const stbrp_rect *q = (const stbrp_rect *) b;
- return (p->was_packed < q->was_packed) ? -1 : (p->was_packed > q->was_packed);
-}
-
-STBRP_DEF int stbrp_pack_rects(stbrp_context *context, stbrp_rect *rects, int num_rects)
-{
- int i, all_rects_packed = 1;
-
- // we use the 'was_packed' field internally to allow sorting/unsorting
- for (i=0; i < num_rects; ++i) {
- rects[i].was_packed = i;
- }
-
- // sort according to heuristic
- STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_height_compare);
-
- for (i=0; i < num_rects; ++i) {
- if (rects[i].w == 0 || rects[i].h == 0) {
- rects[i].x = rects[i].y = 0; // empty rect needs no space
- } else {
- stbrp__findresult fr = stbrp__skyline_pack_rectangle(context, rects[i].w, rects[i].h);
- if (fr.prev_link) {
- rects[i].x = (stbrp_coord) fr.x;
- rects[i].y = (stbrp_coord) fr.y;
- } else {
- rects[i].x = rects[i].y = STBRP__MAXVAL;
- }
- }
- }
-
- // unsort
- STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_original_order);
-
- // set was_packed flags and all_rects_packed status
- for (i=0; i < num_rects; ++i) {
- rects[i].was_packed = !(rects[i].x == STBRP__MAXVAL && rects[i].y == STBRP__MAXVAL);
- if (!rects[i].was_packed)
- all_rects_packed = 0;
- }
-
- // return the all_rects_packed status
- return all_rects_packed;
-}
-#endif
-
-/*
-------------------------------------------------------------------------------
-This software is available under 2 licenses -- choose whichever you prefer.
-------------------------------------------------------------------------------
-ALTERNATIVE A - MIT License
-Copyright (c) 2017 Sean Barrett
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-------------------------------------------------------------------------------
-ALTERNATIVE B - Public Domain (www.unlicense.org)
-This is free and unencumbered software released into the public domain.
-Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
-software, either in source code form or as a compiled binary, for any purpose,
-commercial or non-commercial, and by any means.
-In jurisdictions that recognize copyright laws, the author or authors of this
-software dedicate any and all copyright interest in the software to the public
-domain. We make this dedication for the benefit of the public at large and to
-the detriment of our heirs and successors. We intend this dedication to be an
-overt act of relinquishment in perpetuity of all present and future rights to
-this software under copyright law.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-------------------------------------------------------------------------------
-*/
diff --git a/stb_truetype.h b/stb_truetype.h
deleted file mode 100644
index bbf2284..0000000
--- a/stb_truetype.h
+++ /dev/null
@@ -1,5077 +0,0 @@
-// stb_truetype.h - v1.26 - public domain
-// authored from 2009-2021 by Sean Barrett / RAD Game Tools
-//
-// =======================================================================
-//
-// NO SECURITY GUARANTEE -- DO NOT USE THIS ON UNTRUSTED FONT FILES
-//
-// This library does no range checking of the offsets found in the file,
-// meaning an attacker can use it to read arbitrary memory.
-//
-// =======================================================================
-//
-// This library processes TrueType files:
-// parse files
-// extract glyph metrics
-// extract glyph shapes
-// render glyphs to one-channel bitmaps with antialiasing (box filter)
-// render glyphs to one-channel SDF bitmaps (signed-distance field/function)
-//
-// Todo:
-// non-MS cmaps
-// crashproof on bad data
-// hinting? (no longer patented)
-// cleartype-style AA?
-// optimize: use simple memory allocator for intermediates
-// optimize: build edge-list directly from curves
-// optimize: rasterize directly from curves?
-//
-// ADDITIONAL CONTRIBUTORS
-//
-// Mikko Mononen: compound shape support, more cmap formats
-// Tor Andersson: kerning, subpixel rendering
-// Dougall Johnson: OpenType / Type 2 font handling
-// Daniel Ribeiro Maciel: basic GPOS-based kerning
-//
-// Misc other:
-// Ryan Gordon
-// Simon Glass
-// github:IntellectualKitty
-// Imanol Celaya
-// Daniel Ribeiro Maciel
-//
-// Bug/warning reports/fixes:
-// "Zer" on mollyrocket Fabian "ryg" Giesen github:NiLuJe
-// Cass Everitt Martins Mozeiko github:aloucks
-// stoiko (Haemimont Games) Cap Petschulat github:oyvindjam
-// Brian Hook Omar Cornut github:vassvik
-// Walter van Niftrik Ryan Griege
-// David Gow Peter LaValle
-// David Given Sergey Popov
-// Ivan-Assen Ivanov Giumo X. Clanjor
-// Anthony Pesch Higor Euripedes
-// Johan Duparc Thomas Fields
-// Hou Qiming Derek Vinyard
-// Rob Loach Cort Stratton
-// Kenney Phillis Jr. Brian Costabile
-// Ken Voskuil (kaesve)
-//
-// VERSION HISTORY
-//
-// 1.26 (2021-08-28) fix broken rasterizer
-// 1.25 (2021-07-11) many fixes
-// 1.24 (2020-02-05) fix warning
-// 1.23 (2020-02-02) query SVG data for glyphs; query whole kerning table (but only kern not GPOS)
-// 1.22 (2019-08-11) minimize missing-glyph duplication; fix kerning if both 'GPOS' and 'kern' are defined
-// 1.21 (2019-02-25) fix warning
-// 1.20 (2019-02-07) PackFontRange skips missing codepoints; GetScaleFontVMetrics()
-// 1.19 (2018-02-11) GPOS kerning, STBTT_fmod
-// 1.18 (2018-01-29) add missing function
-// 1.17 (2017-07-23) make more arguments const; doc fix
-// 1.16 (2017-07-12) SDF support
-// 1.15 (2017-03-03) make more arguments const
-// 1.14 (2017-01-16) num-fonts-in-TTC function
-// 1.13 (2017-01-02) support OpenType fonts, certain Apple fonts
-// 1.12 (2016-10-25) suppress warnings about casting away const with -Wcast-qual
-// 1.11 (2016-04-02) fix unused-variable warning
-// 1.10 (2016-04-02) user-defined fabs(); rare memory leak; remove duplicate typedef
-// 1.09 (2016-01-16) warning fix; avoid crash on outofmem; use allocation userdata properly
-// 1.08 (2015-09-13) document stbtt_Rasterize(); fixes for vertical & horizontal edges
-// 1.07 (2015-08-01) allow PackFontRanges to accept arrays of sparse codepoints;
-// variant PackFontRanges to pack and render in separate phases;
-// fix stbtt_GetFontOFfsetForIndex (never worked for non-0 input?);
-// fixed an assert() bug in the new rasterizer
-// replace assert() with STBTT_assert() in new rasterizer
-//
-// Full history can be found at the end of this file.
-//
-// LICENSE
-//
-// See end of file for license information.
-//
-// USAGE
-//
-// Include this file in whatever places need to refer to it. In ONE C/C++
-// file, write:
-// #define STB_TRUETYPE_IMPLEMENTATION
-// before the #include of this file. This expands out the actual
-// implementation into that C/C++ file.
-//
-// To make the implementation private to the file that generates the implementation,
-// #define STBTT_STATIC
-//
-// Simple 3D API (don't ship this, but it's fine for tools and quick start)
-// stbtt_BakeFontBitmap() -- bake a font to a bitmap for use as texture
-// stbtt_GetBakedQuad() -- compute quad to draw for a given char
-//
-// Improved 3D API (more shippable):
-// #include "stb_rect_pack.h" -- optional, but you really want it
-// stbtt_PackBegin()
-// stbtt_PackSetOversampling() -- for improved quality on small fonts
-// stbtt_PackFontRanges() -- pack and renders
-// stbtt_PackEnd()
-// stbtt_GetPackedQuad()
-//
-// "Load" a font file from a memory buffer (you have to keep the buffer loaded)
-// stbtt_InitFont()
-// stbtt_GetFontOffsetForIndex() -- indexing for TTC font collections
-// stbtt_GetNumberOfFonts() -- number of fonts for TTC font collections
-//
-// Render a unicode codepoint to a bitmap
-// stbtt_GetCodepointBitmap() -- allocates and returns a bitmap
-// stbtt_MakeCodepointBitmap() -- renders into bitmap you provide
-// stbtt_GetCodepointBitmapBox() -- how big the bitmap must be
-//
-// Character advance/positioning
-// stbtt_GetCodepointHMetrics()
-// stbtt_GetFontVMetrics()
-// stbtt_GetFontVMetricsOS2()
-// stbtt_GetCodepointKernAdvance()
-//
-// Starting with version 1.06, the rasterizer was replaced with a new,
-// faster and generally-more-precise rasterizer. The new rasterizer more
-// accurately measures pixel coverage for anti-aliasing, except in the case
-// where multiple shapes overlap, in which case it overestimates the AA pixel
-// coverage. Thus, anti-aliasing of intersecting shapes may look wrong. If
-// this turns out to be a problem, you can re-enable the old rasterizer with
-// #define STBTT_RASTERIZER_VERSION 1
-// which will incur about a 15% speed hit.
-//
-// ADDITIONAL DOCUMENTATION
-//
-// Immediately after this block comment are a series of sample programs.
-//
-// After the sample programs is the "header file" section. This section
-// includes documentation for each API function.
-//
-// Some important concepts to understand to use this library:
-//
-// Codepoint
-// Characters are defined by unicode codepoints, e.g. 65 is
-// uppercase A, 231 is lowercase c with a cedilla, 0x7e30 is
-// the hiragana for "ma".
-//
-// Glyph
-// A visual character shape (every codepoint is rendered as
-// some glyph)
-//
-// Glyph index
-// A font-specific integer ID representing a glyph
-//
-// Baseline
-// Glyph shapes are defined relative to a baseline, which is the
-// bottom of uppercase characters. Characters extend both above
-// and below the baseline.
-//
-// Current Point
-// As you draw text to the screen, you keep track of a "current point"
-// which is the origin of each character. The current point's vertical
-// position is the baseline. Even "baked fonts" use this model.
-//
-// Vertical Font Metrics
-// The vertical qualities of the font, used to vertically position
-// and space the characters. See docs for stbtt_GetFontVMetrics.
-//
-// Font Size in Pixels or Points
-// The preferred interface for specifying font sizes in stb_truetype
-// is to specify how tall the font's vertical extent should be in pixels.
-// If that sounds good enough, skip the next paragraph.
-//
-// Most font APIs instead use "points", which are a common typographic
-// measurement for describing font size, defined as 72 points per inch.
-// stb_truetype provides a point API for compatibility. However, true
-// "per inch" conventions don't make much sense on computer displays
-// since different monitors have different number of pixels per
-// inch. For example, Windows traditionally uses a convention that
-// there are 96 pixels per inch, thus making 'inch' measurements have
-// nothing to do with inches, and thus effectively defining a point to
-// be 1.333 pixels. Additionally, the TrueType font data provides
-// an explicit scale factor to scale a given font's glyphs to points,
-// but the author has observed that this scale factor is often wrong
-// for non-commercial fonts, thus making fonts scaled in points
-// according to the TrueType spec incoherently sized in practice.
-//
-// DETAILED USAGE:
-//
-// Scale:
-// Select how high you want the font to be, in points or pixels.
-// Call ScaleForPixelHeight or ScaleForMappingEmToPixels to compute
-// a scale factor SF that will be used by all other functions.
-//
-// Baseline:
-// You need to select a y-coordinate that is the baseline of where
-// your text will appear. Call GetFontBoundingBox to get the baseline-relative
-// bounding box for all characters. SF*-y0 will be the distance in pixels
-// that the worst-case character could extend above the baseline, so if
-// you want the top edge of characters to appear at the top of the
-// screen where y=0, then you would set the baseline to SF*-y0.
-//
-// Current point:
-// Set the current point where the first character will appear. The
-// first character could extend left of the current point; this is font
-// dependent. You can either choose a current point that is the leftmost
-// point and hope, or add some padding, or check the bounding box or
-// left-side-bearing of the first character to be displayed and set
-// the current point based on that.
-//
-// Displaying a character:
-// Compute the bounding box of the character. It will contain signed values
-// relative to <current_point, baseline>. I.e. if it returns x0,y0,x1,y1,
-// then the character should be displayed in the rectangle from
-// <current_point+SF*x0, baseline+SF*y0> to <current_point+SF*x1,baseline+SF*y1).
-//
-// Advancing for the next character:
-// Call GlyphHMetrics, and compute 'current_point += SF * advance'.
-//
-//
-// ADVANCED USAGE
-//
-// Quality:
-//
-// - Use the functions with Subpixel at the end to allow your characters
-// to have subpixel positioning. Since the font is anti-aliased, not
-// hinted, this is very import for quality. (This is not possible with
-// baked fonts.)
-//
-// - Kerning is now supported, and if you're supporting subpixel rendering
-// then kerning is worth using to give your text a polished look.
-//
-// Performance:
-//
-// - Convert Unicode codepoints to glyph indexes and operate on the glyphs;
-// if you don't do this, stb_truetype is forced to do the conversion on
-// every call.
-//
-// - There are a lot of memory allocations. We should modify it to take
-// a temp buffer and allocate from the temp buffer (without freeing),
-// should help performance a lot.
-//
-// NOTES
-//
-// The system uses the raw data found in the .ttf file without changing it
-// and without building auxiliary data structures. This is a bit inefficient
-// on little-endian systems (the data is big-endian), but assuming you're
-// caching the bitmaps or glyph shapes this shouldn't be a big deal.
-//
-// It appears to be very hard to programmatically determine what font a
-// given file is in a general way. I provide an API for this, but I don't
-// recommend it.
-//
-//
-// PERFORMANCE MEASUREMENTS FOR 1.06:
-//
-// 32-bit 64-bit
-// Previous release: 8.83 s 7.68 s
-// Pool allocations: 7.72 s 6.34 s
-// Inline sort : 6.54 s 5.65 s
-// New rasterizer : 5.63 s 5.00 s
-
-//////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////
-////
-//// SAMPLE PROGRAMS
-////
-//
-// Incomplete text-in-3d-api example, which draws quads properly aligned to be lossless.
-// See "tests/truetype_demo_win32.c" for a complete version.
-#if 0
-#define STB_TRUETYPE_IMPLEMENTATION // force following include to generate implementation
-#include "stb_truetype.h"
-
-unsigned char ttf_buffer[1<<20];
-unsigned char temp_bitmap[512*512];
-
-stbtt_bakedchar cdata[96]; // ASCII 32..126 is 95 glyphs
-GLuint ftex;
-
-void my_stbtt_initfont(void)
-{
- fread(ttf_buffer, 1, 1<<20, fopen("c:/windows/fonts/times.ttf", "rb"));
- stbtt_BakeFontBitmap(ttf_buffer,0, 32.0, temp_bitmap,512,512, 32,96, cdata); // no guarantee this fits!
- // can free ttf_buffer at this point
- glGenTextures(1, &ftex);
- glBindTexture(GL_TEXTURE_2D, ftex);
- glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, 512,512, 0, GL_ALPHA, GL_UNSIGNED_BYTE, temp_bitmap);
- // can free temp_bitmap at this point
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-}
-
-void my_stbtt_print(float x, float y, char *text)
-{
- // assume orthographic projection with units = screen pixels, origin at top left
- glEnable(GL_BLEND);
- glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
- glEnable(GL_TEXTURE_2D);
- glBindTexture(GL_TEXTURE_2D, ftex);
- glBegin(GL_QUADS);
- while (*text) {
- if (*text >= 32 && *text < 128) {
- stbtt_aligned_quad q;
- stbtt_GetBakedQuad(cdata, 512,512, *text-32, &x,&y,&q,1);//1=opengl & d3d10+,0=d3d9
- glTexCoord2f(q.s0,q.t0); glVertex2f(q.x0,q.y0);
- glTexCoord2f(q.s1,q.t0); glVertex2f(q.x1,q.y0);
- glTexCoord2f(q.s1,q.t1); glVertex2f(q.x1,q.y1);
- glTexCoord2f(q.s0,q.t1); glVertex2f(q.x0,q.y1);
- }
- ++text;
- }
- glEnd();
-}
-#endif
-//
-//
-//////////////////////////////////////////////////////////////////////////////
-//
-// Complete program (this compiles): get a single bitmap, print as ASCII art
-//
-#if 0
-#include <stdio.h>
-#define STB_TRUETYPE_IMPLEMENTATION // force following include to generate implementation
-#include "stb_truetype.h"
-
-char ttf_buffer[1<<25];
-
-int main(int argc, char **argv)
-{
- stbtt_fontinfo font;
- unsigned char *bitmap;
- int w,h,i,j,c = (argc > 1 ? atoi(argv[1]) : 'a'), s = (argc > 2 ? atoi(argv[2]) : 20);
-
- fread(ttf_buffer, 1, 1<<25, fopen(argc > 3 ? argv[3] : "c:/windows/fonts/arialbd.ttf", "rb"));
-
- stbtt_InitFont(&font, ttf_buffer, stbtt_GetFontOffsetForIndex(ttf_buffer,0));
- bitmap = stbtt_GetCodepointBitmap(&font, 0,stbtt_ScaleForPixelHeight(&font, s), c, &w, &h, 0,0);
-
- for (j=0; j < h; ++j) {
- for (i=0; i < w; ++i)
- putchar(" .:ioVM@"[bitmap[j*w+i]>>5]);
- putchar('\n');
- }
- return 0;
-}
-#endif
-//
-// Output:
-//
-// .ii.
-// @@@@@@.
-// V@Mio@@o
-// :i. V@V
-// :oM@@M
-// :@@@MM@M
-// @@o o@M
-// :@@. M@M
-// @@@o@@@@
-// :M@@V:@@.
-//
-//////////////////////////////////////////////////////////////////////////////
-//
-// Complete program: print "Hello World!" banner, with bugs
-//
-#if 0
-char buffer[24<<20];
-unsigned char screen[20][79];
-
-int main(int arg, char **argv)
-{
- stbtt_fontinfo font;
- int i,j,ascent,baseline,ch=0;
- float scale, xpos=2; // leave a little padding in case the character extends left
- char *text = "Heljo World!"; // intentionally misspelled to show 'lj' brokenness
-
- fread(buffer, 1, 1000000, fopen("c:/windows/fonts/arialbd.ttf", "rb"));
- stbtt_InitFont(&font, buffer, 0);
-
- scale = stbtt_ScaleForPixelHeight(&font, 15);
- stbtt_GetFontVMetrics(&font, &ascent,0,0);
- baseline = (int) (ascent*scale);
-
- while (text[ch]) {
- int advance,lsb,x0,y0,x1,y1;
- float x_shift = xpos - (float) floor(xpos);
- stbtt_GetCodepointHMetrics(&font, text[ch], &advance, &lsb);
- stbtt_GetCodepointBitmapBoxSubpixel(&font, text[ch], scale,scale,x_shift,0, &x0,&y0,&x1,&y1);
- stbtt_MakeCodepointBitmapSubpixel(&font, &screen[baseline + y0][(int) xpos + x0], x1-x0,y1-y0, 79, scale,scale,x_shift,0, text[ch]);
- // note that this stomps the old data, so where character boxes overlap (e.g. 'lj') it's wrong
- // because this API is really for baking character bitmaps into textures. if you want to render
- // a sequence of characters, you really need to render each bitmap to a temp buffer, then
- // "alpha blend" that into the working buffer
- xpos += (advance * scale);
- if (text[ch+1])
- xpos += scale*stbtt_GetCodepointKernAdvance(&font, text[ch],text[ch+1]);
- ++ch;
- }
-
- for (j=0; j < 20; ++j) {
- for (i=0; i < 78; ++i)
- putchar(" .:ioVM@"[screen[j][i]>>5]);
- putchar('\n');
- }
-
- return 0;
-}
-#endif
-
-
-//////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////
-////
-//// INTEGRATION WITH YOUR CODEBASE
-////
-//// The following sections allow you to supply alternate definitions
-//// of C library functions used by stb_truetype, e.g. if you don't
-//// link with the C runtime library.
-
-#ifdef STB_TRUETYPE_IMPLEMENTATION
- // #define your own (u)stbtt_int8/16/32 before including to override this
- #ifndef stbtt_uint8
- typedef unsigned char stbtt_uint8;
- typedef signed char stbtt_int8;
- typedef unsigned short stbtt_uint16;
- typedef signed short stbtt_int16;
- typedef unsigned int stbtt_uint32;
- typedef signed int stbtt_int32;
- #endif
-
- typedef char stbtt__check_size32[sizeof(stbtt_int32)==4 ? 1 : -1];
- typedef char stbtt__check_size16[sizeof(stbtt_int16)==2 ? 1 : -1];
-
- // e.g. #define your own STBTT_ifloor/STBTT_iceil() to avoid math.h
- #ifndef STBTT_ifloor
- #include <math.h>
- #define STBTT_ifloor(x) ((int) floor(x))
- #define STBTT_iceil(x) ((int) ceil(x))
- #endif
-
- #ifndef STBTT_sqrt
- #include <math.h>
- #define STBTT_sqrt(x) sqrt(x)
- #define STBTT_pow(x,y) pow(x,y)
- #endif
-
- #ifndef STBTT_fmod
- #include <math.h>
- #define STBTT_fmod(x,y) fmod(x,y)
- #endif
-
- #ifndef STBTT_cos
- #include <math.h>
- #define STBTT_cos(x) cos(x)
- #define STBTT_acos(x) acos(x)
- #endif
-
- #ifndef STBTT_fabs
- #include <math.h>
- #define STBTT_fabs(x) fabs(x)
- #endif
-
- // #define your own functions "STBTT_malloc" / "STBTT_free" to avoid malloc.h
- #ifndef STBTT_malloc
- #include <stdlib.h>
- #define STBTT_malloc(x,u) ((void)(u),malloc(x))
- #define STBTT_free(x,u) ((void)(u),free(x))
- #endif
-
- #ifndef STBTT_assert
- #include <assert.h>
- #define STBTT_assert(x) assert(x)
- #endif
-
- #ifndef STBTT_strlen
- #include <string.h>
- #define STBTT_strlen(x) strlen(x)
- #endif
-
- #ifndef STBTT_memcpy
- #include <string.h>
- #define STBTT_memcpy memcpy
- #define STBTT_memset memset
- #endif
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-////
-//// INTERFACE
-////
-////
-
-#ifndef __STB_INCLUDE_STB_TRUETYPE_H__
-#define __STB_INCLUDE_STB_TRUETYPE_H__
-
-#ifdef STBTT_STATIC
-#define STBTT_DEF static
-#else
-#define STBTT_DEF extern
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// private structure
-typedef struct
-{
- unsigned char *data;
- int cursor;
- int size;
-} stbtt__buf;
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// TEXTURE BAKING API
-//
-// If you use this API, you only have to call two functions ever.
-//
-
-typedef struct
-{
- unsigned short x0,y0,x1,y1; // coordinates of bbox in bitmap
- float xoff,yoff,xadvance;
-} stbtt_bakedchar;
-
-STBTT_DEF int stbtt_BakeFontBitmap(const unsigned char *data, int offset, // font location (use offset=0 for plain .ttf)
- float pixel_height, // height of font in pixels
- unsigned char *pixels, int pw, int ph, // bitmap to be filled in
- int first_char, int num_chars, // characters to bake
- stbtt_bakedchar *chardata); // you allocate this, it's num_chars long
-// if return is positive, the first unused row of the bitmap
-// if return is negative, returns the negative of the number of characters that fit
-// if return is 0, no characters fit and no rows were used
-// This uses a very crappy packing.
-
-typedef struct
-{
- float x0,y0,s0,t0; // top-left
- float x1,y1,s1,t1; // bottom-right
-} stbtt_aligned_quad;
-
-STBTT_DEF void stbtt_GetBakedQuad(const stbtt_bakedchar *chardata, int pw, int ph, // same data as above
- int char_index, // character to display
- float *xpos, float *ypos, // pointers to current position in screen pixel space
- stbtt_aligned_quad *q, // output: quad to draw
- int opengl_fillrule); // true if opengl fill rule; false if DX9 or earlier
-// Call GetBakedQuad with char_index = 'character - first_char', and it
-// creates the quad you need to draw and advances the current position.
-//
-// The coordinate system used assumes y increases downwards.
-//
-// Characters will extend both above and below the current position;
-// see discussion of "BASELINE" above.
-//
-// It's inefficient; you might want to c&p it and optimize it.
-
-STBTT_DEF void stbtt_GetScaledFontVMetrics(const unsigned char *fontdata, int index, float size, float *ascent, float *descent, float *lineGap);
-// Query the font vertical metrics without having to create a font first.
-
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// NEW TEXTURE BAKING API
-//
-// This provides options for packing multiple fonts into one atlas, not
-// perfectly but better than nothing.
-
-typedef struct
-{
- unsigned short x0,y0,x1,y1; // coordinates of bbox in bitmap
- float xoff,yoff,xadvance;
- float xoff2,yoff2;
-} stbtt_packedchar;
-
-typedef struct stbtt_pack_context stbtt_pack_context;
-typedef struct stbtt_fontinfo stbtt_fontinfo;
-#ifndef STB_RECT_PACK_VERSION
-typedef struct stbrp_rect stbrp_rect;
-#endif
-
-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);
-// Initializes a packing context stored in the passed-in stbtt_pack_context.
-// Future calls using this context will pack characters into the bitmap passed
-// in here: a 1-channel bitmap that is width * height. stride_in_bytes is
-// the distance from one row to the next (or 0 to mean they are packed tightly
-// together). "padding" is the amount of padding to leave between each
-// character (normally you want '1' for bitmaps you'll use as textures with
-// bilinear filtering).
-//
-// Returns 0 on failure, 1 on success.
-
-STBTT_DEF void stbtt_PackEnd (stbtt_pack_context *spc);
-// Cleans up the packing context and frees all memory.
-
-#define STBTT_POINT_SIZE(x) (-(x))
-
-STBTT_DEF int stbtt_PackFontRange(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, float font_size,
- int first_unicode_char_in_range, int num_chars_in_range, stbtt_packedchar *chardata_for_range);
-// Creates character bitmaps from the font_index'th font found in fontdata (use
-// font_index=0 if you don't know what that is). It creates num_chars_in_range
-// bitmaps for characters with unicode values starting at first_unicode_char_in_range
-// and increasing. Data for how to render them is stored in chardata_for_range;
-// pass these to stbtt_GetPackedQuad to get back renderable quads.
-//
-// font_size is the full height of the character from ascender to descender,
-// as computed by stbtt_ScaleForPixelHeight. To use a point size as computed
-// by stbtt_ScaleForMappingEmToPixels, wrap the point size in STBTT_POINT_SIZE()
-// and pass that result as 'font_size':
-// ..., 20 , ... // font max minus min y is 20 pixels tall
-// ..., STBTT_POINT_SIZE(20), ... // 'M' is 20 pixels tall
-
-typedef struct
-{
- float font_size;
- int first_unicode_codepoint_in_range; // if non-zero, then the chars are continuous, and this is the first codepoint
- int *array_of_unicode_codepoints; // if non-zero, then this is an array of unicode codepoints
- int num_chars;
- stbtt_packedchar *chardata_for_range; // output
- unsigned char h_oversample, v_oversample; // don't set these, they're used internally
-} stbtt_pack_range;
-
-STBTT_DEF int stbtt_PackFontRanges(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, stbtt_pack_range *ranges, int num_ranges);
-// Creates character bitmaps from multiple ranges of characters stored in
-// ranges. This will usually create a better-packed bitmap than multiple
-// calls to stbtt_PackFontRange. Note that you can call this multiple
-// times within a single PackBegin/PackEnd.
-
-STBTT_DEF void stbtt_PackSetOversampling(stbtt_pack_context *spc, unsigned int h_oversample, unsigned int v_oversample);
-// Oversampling a font increases the quality by allowing higher-quality subpixel
-// positioning, and is especially valuable at smaller text sizes.
-//
-// This function sets the amount of oversampling for all following calls to
-// stbtt_PackFontRange(s) or stbtt_PackFontRangesGatherRects for a given
-// pack context. The default (no oversampling) is achieved by h_oversample=1
-// and v_oversample=1. The total number of pixels required is
-// h_oversample*v_oversample larger than the default; for example, 2x2
-// oversampling requires 4x the storage of 1x1. For best results, render
-// oversampled textures with bilinear filtering. Look at the readme in
-// stb/tests/oversample for information about oversampled fonts
-//
-// To use with PackFontRangesGather etc., you must set it before calls
-// call to PackFontRangesGatherRects.
-
-STBTT_DEF void stbtt_PackSetSkipMissingCodepoints(stbtt_pack_context *spc, int skip);
-// If skip != 0, this tells stb_truetype to skip any codepoints for which
-// there is no corresponding glyph. If skip=0, which is the default, then
-// codepoints without a glyph recived the font's "missing character" glyph,
-// typically an empty box by convention.
-
-STBTT_DEF void stbtt_GetPackedQuad(const stbtt_packedchar *chardata, int pw, int ph, // same data as above
- int char_index, // character to display
- float *xpos, float *ypos, // pointers to current position in screen pixel space
- stbtt_aligned_quad *q, // output: quad to draw
- int align_to_integer);
-
-STBTT_DEF int stbtt_PackFontRangesGatherRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects);
-STBTT_DEF void stbtt_PackFontRangesPackRects(stbtt_pack_context *spc, stbrp_rect *rects, int num_rects);
-STBTT_DEF int stbtt_PackFontRangesRenderIntoRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects);
-// Calling these functions in sequence is roughly equivalent to calling
-// stbtt_PackFontRanges(). If you more control over the packing of multiple
-// fonts, or if you want to pack custom data into a font texture, take a look
-// at the source to of stbtt_PackFontRanges() and create a custom version
-// using these functions, e.g. call GatherRects multiple times,
-// building up a single array of rects, then call PackRects once,
-// then call RenderIntoRects repeatedly. This may result in a
-// better packing than calling PackFontRanges multiple times
-// (or it may not).
-
-// this is an opaque structure that you shouldn't mess with which holds
-// all the context needed from PackBegin to PackEnd.
-struct stbtt_pack_context {
- void *user_allocator_context;
- void *pack_info;
- int width;
- int height;
- int stride_in_bytes;
- int padding;
- int skip_missing;
- unsigned int h_oversample, v_oversample;
- unsigned char *pixels;
- void *nodes;
-};
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// FONT LOADING
-//
-//
-
-STBTT_DEF int stbtt_GetNumberOfFonts(const unsigned char *data);
-// This function will determine the number of fonts in a font file. TrueType
-// collection (.ttc) files may contain multiple fonts, while TrueType font
-// (.ttf) files only contain one font. The number of fonts can be used for
-// indexing with the previous function where the index is between zero and one
-// less than the total fonts. If an error occurs, -1 is returned.
-
-STBTT_DEF int stbtt_GetFontOffsetForIndex(const unsigned char *data, int index);
-// Each .ttf/.ttc file may have more than one font. Each font has a sequential
-// index number starting from 0. Call this function to get the font offset for
-// a given index; it returns -1 if the index is out of range. A regular .ttf
-// file will only define one font and it always be at offset 0, so it will
-// return '0' for index 0, and -1 for all other indices.
-
-// The following structure is defined publicly so you can declare one on
-// the stack or as a global or etc, but you should treat it as opaque.
-struct stbtt_fontinfo
-{
- void * userdata;
- unsigned char * data; // pointer to .ttf file
- int fontstart; // offset of start of font
-
- int numGlyphs; // number of glyphs, needed for range checking
-
- int loca,head,glyf,hhea,hmtx,kern,gpos,svg; // table locations as offset from start of .ttf
- int index_map; // a cmap mapping for our chosen character encoding
- int indexToLocFormat; // format needed to map from glyph index to glyph
-
- stbtt__buf cff; // cff font data
- stbtt__buf charstrings; // the charstring index
- stbtt__buf gsubrs; // global charstring subroutines index
- stbtt__buf subrs; // private charstring subroutines index
- stbtt__buf fontdicts; // array of font dicts
- stbtt__buf fdselect; // map from glyph to fontdict
-};
-
-STBTT_DEF int stbtt_InitFont(stbtt_fontinfo *info, const unsigned char *data, int offset);
-// Given an offset into the file that defines a font, this function builds
-// the necessary cached info for the rest of the system. You must allocate
-// the stbtt_fontinfo yourself, and stbtt_InitFont will fill it out. You don't
-// need to do anything special to free it, because the contents are pure
-// value data with no additional data structures. Returns 0 on failure.
-
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// CHARACTER TO GLYPH-INDEX CONVERSIOn
-
-STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codepoint);
-// If you're going to perform multiple operations on the same character
-// and you want a speed-up, call this function with the character you're
-// going to process, then use glyph-based functions instead of the
-// codepoint-based functions.
-// Returns 0 if the character codepoint is not defined in the font.
-
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// CHARACTER PROPERTIES
-//
-
-STBTT_DEF float stbtt_ScaleForPixelHeight(const stbtt_fontinfo *info, float pixels);
-// computes a scale factor to produce a font whose "height" is 'pixels' tall.
-// Height is measured as the distance from the highest ascender to the lowest
-// descender; in other words, it's equivalent to calling stbtt_GetFontVMetrics
-// and computing:
-// scale = pixels / (ascent - descent)
-// so if you prefer to measure height by the ascent only, use a similar calculation.
-
-STBTT_DEF float stbtt_ScaleForMappingEmToPixels(const stbtt_fontinfo *info, float pixels);
-// computes a scale factor to produce a font whose EM size is mapped to
-// 'pixels' tall. This is probably what traditional APIs compute, but
-// I'm not positive.
-
-STBTT_DEF void stbtt_GetFontVMetrics(const stbtt_fontinfo *info, int *ascent, int *descent, int *lineGap);
-// ascent is the coordinate above the baseline the font extends; descent
-// is the coordinate below the baseline the font extends (i.e. it is typically negative)
-// lineGap is the spacing between one row's descent and the next row's ascent...
-// so you should advance the vertical position by "*ascent - *descent + *lineGap"
-// these are expressed in unscaled coordinates, so you must multiply by
-// the scale factor for a given size
-
-STBTT_DEF int stbtt_GetFontVMetricsOS2(const stbtt_fontinfo *info, int *typoAscent, int *typoDescent, int *typoLineGap);
-// analogous to GetFontVMetrics, but returns the "typographic" values from the OS/2
-// table (specific to MS/Windows TTF files).
-//
-// Returns 1 on success (table present), 0 on failure.
-
-STBTT_DEF void stbtt_GetFontBoundingBox(const stbtt_fontinfo *info, int *x0, int *y0, int *x1, int *y1);
-// the bounding box around all possible characters
-
-STBTT_DEF void stbtt_GetCodepointHMetrics(const stbtt_fontinfo *info, int codepoint, int *advanceWidth, int *leftSideBearing);
-// leftSideBearing is the offset from the current horizontal position to the left edge of the character
-// advanceWidth is the offset from the current horizontal position to the next horizontal position
-// these are expressed in unscaled coordinates
-
-STBTT_DEF int stbtt_GetCodepointKernAdvance(const stbtt_fontinfo *info, int ch1, int ch2);
-// an additional amount to add to the 'advance' value between ch1 and ch2
-
-STBTT_DEF int stbtt_GetCodepointBox(const stbtt_fontinfo *info, int codepoint, int *x0, int *y0, int *x1, int *y1);
-// Gets the bounding box of the visible part of the glyph, in unscaled coordinates
-
-STBTT_DEF void stbtt_GetGlyphHMetrics(const stbtt_fontinfo *info, int glyph_index, int *advanceWidth, int *leftSideBearing);
-STBTT_DEF int stbtt_GetGlyphKernAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2);
-STBTT_DEF int stbtt_GetGlyphBox(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1);
-// as above, but takes one or more glyph indices for greater efficiency
-
-typedef struct stbtt_kerningentry
-{
- int glyph1; // use stbtt_FindGlyphIndex
- int glyph2;
- int advance;
-} stbtt_kerningentry;
-
-STBTT_DEF int stbtt_GetKerningTableLength(const stbtt_fontinfo *info);
-STBTT_DEF int stbtt_GetKerningTable(const stbtt_fontinfo *info, stbtt_kerningentry* table, int table_length);
-// Retrieves a complete list of all of the kerning pairs provided by the font
-// stbtt_GetKerningTable never writes more than table_length entries and returns how many entries it did write.
-// The table will be sorted by (a.glyph1 == b.glyph1)?(a.glyph2 < b.glyph2):(a.glyph1 < b.glyph1)
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// GLYPH SHAPES (you probably don't need these, but they have to go before
-// the bitmaps for C declaration-order reasons)
-//
-
-#ifndef STBTT_vmove // you can predefine these to use different values (but why?)
- enum {
- STBTT_vmove=1,
- STBTT_vline,
- STBTT_vcurve,
- STBTT_vcubic
- };
-#endif
-
-#ifndef stbtt_vertex // you can predefine this to use different values
- // (we share this with other code at RAD)
- #define stbtt_vertex_type short // can't use stbtt_int16 because that's not visible in the header file
- typedef struct
- {
- stbtt_vertex_type x,y,cx,cy,cx1,cy1;
- unsigned char type,padding;
- } stbtt_vertex;
-#endif
-
-STBTT_DEF int stbtt_IsGlyphEmpty(const stbtt_fontinfo *info, int glyph_index);
-// returns non-zero if nothing is drawn for this glyph
-
-STBTT_DEF int stbtt_GetCodepointShape(const stbtt_fontinfo *info, int unicode_codepoint, stbtt_vertex **vertices);
-STBTT_DEF int stbtt_GetGlyphShape(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **vertices);
-// returns # of vertices and fills *vertices with the pointer to them
-// these are expressed in "unscaled" coordinates
-//
-// The shape is a series of contours. Each one starts with
-// a STBTT_moveto, then consists of a series of mixed
-// STBTT_lineto and STBTT_curveto segments. A lineto
-// draws a line from previous endpoint to its x,y; a curveto
-// draws a quadratic bezier from previous endpoint to
-// its x,y, using cx,cy as the bezier control point.
-
-STBTT_DEF void stbtt_FreeShape(const stbtt_fontinfo *info, stbtt_vertex *vertices);
-// frees the data allocated above
-
-STBTT_DEF unsigned char *stbtt_FindSVGDoc(const stbtt_fontinfo *info, int gl);
-STBTT_DEF int stbtt_GetCodepointSVG(const stbtt_fontinfo *info, int unicode_codepoint, const char **svg);
-STBTT_DEF int stbtt_GetGlyphSVG(const stbtt_fontinfo *info, int gl, const char **svg);
-// fills svg with the character's SVG data.
-// returns data size or 0 if SVG not found.
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// BITMAP RENDERING
-//
-
-STBTT_DEF void stbtt_FreeBitmap(unsigned char *bitmap, void *userdata);
-// frees the bitmap allocated below
-
-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);
-// allocates a large-enough single-channel 8bpp bitmap and renders the
-// specified character/glyph at the specified scale into it, with
-// antialiasing. 0 is no coverage (transparent), 255 is fully covered (opaque).
-// *width & *height are filled out with the width & height of the bitmap,
-// which is stored left-to-right, top-to-bottom.
-//
-// xoff/yoff are the offset it pixel space from the glyph origin to the top-left of the bitmap
-
-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);
-// the same as stbtt_GetCodepoitnBitmap, but you can specify a subpixel
-// shift for the character
-
-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);
-// the same as stbtt_GetCodepointBitmap, but you pass in storage for the bitmap
-// in the form of 'output', with row spacing of 'out_stride' bytes. the bitmap
-// is clipped to out_w/out_h bytes. Call stbtt_GetCodepointBitmapBox to get the
-// width and height and positioning info for it first.
-
-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);
-// same as stbtt_MakeCodepointBitmap, but you can specify a subpixel
-// shift for the character
-
-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);
-// same as stbtt_MakeCodepointBitmapSubpixel, but prefiltering
-// is performed (see stbtt_PackSetOversampling)
-
-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);
-// get the bbox of the bitmap centered around the glyph origin; so the
-// bitmap width is ix1-ix0, height is iy1-iy0, and location to place
-// the bitmap top left is (leftSideBearing*scale,iy0).
-// (Note that the bitmap uses y-increases-down, but the shape uses
-// y-increases-up, so CodepointBitmapBox and CodepointBox are inverted.)
-
-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);
-// same as stbtt_GetCodepointBitmapBox, but you can specify a subpixel
-// shift for the character
-
-// the following functions are equivalent to the above functions, but operate
-// on glyph indices instead of Unicode codepoints (for efficiency)
-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);
-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);
-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);
-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);
-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);
-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);
-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);
-
-
-// @TODO: don't expose this structure
-typedef struct
-{
- int w,h,stride;
- unsigned char *pixels;
-} stbtt__bitmap;
-
-// rasterize a shape with quadratic beziers into a bitmap
-STBTT_DEF void stbtt_Rasterize(stbtt__bitmap *result, // 1-channel bitmap to draw into
- float flatness_in_pixels, // allowable error of curve in pixels
- stbtt_vertex *vertices, // array of vertices defining shape
- int num_verts, // number of vertices in above array
- float scale_x, float scale_y, // scale applied to input vertices
- float shift_x, float shift_y, // translation applied to input vertices
- int x_off, int y_off, // another translation applied to input
- int invert, // if non-zero, vertically flip shape
- void *userdata); // context for to STBTT_MALLOC
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// Signed Distance Function (or Field) rendering
-
-STBTT_DEF void stbtt_FreeSDF(unsigned char *bitmap, void *userdata);
-// frees the SDF bitmap allocated below
-
-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);
-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);
-// These functions compute a discretized SDF field for a single character, suitable for storing
-// in a single-channel texture, sampling with bilinear filtering, and testing against
-// larger than some threshold to produce scalable fonts.
-// info -- the font
-// scale -- controls the size of the resulting SDF bitmap, same as it would be creating a regular bitmap
-// glyph/codepoint -- the character to generate the SDF for
-// padding -- extra "pixels" around the character which are filled with the distance to the character (not 0),
-// which allows effects like bit outlines
-// onedge_value -- value 0-255 to test the SDF against to reconstruct the character (i.e. the isocontour of the character)
-// pixel_dist_scale -- what value the SDF should increase by when moving one SDF "pixel" away from the edge (on the 0..255 scale)
-// if positive, > onedge_value is inside; if negative, < onedge_value is inside
-// width,height -- output height & width of the SDF bitmap (including padding)
-// xoff,yoff -- output origin of the character
-// return value -- a 2D array of bytes 0..255, width*height in size
-//
-// pixel_dist_scale & onedge_value are a scale & bias that allows you to make
-// optimal use of the limited 0..255 for your application, trading off precision
-// and special effects. SDF values outside the range 0..255 are clamped to 0..255.
-//
-// Example:
-// scale = stbtt_ScaleForPixelHeight(22)
-// padding = 5
-// onedge_value = 180
-// pixel_dist_scale = 180/5.0 = 36.0
-//
-// This will create an SDF bitmap in which the character is about 22 pixels
-// high but the whole bitmap is about 22+5+5=32 pixels high. To produce a filled
-// shape, sample the SDF at each pixel and fill the pixel if the SDF value
-// is greater than or equal to 180/255. (You'll actually want to antialias,
-// which is beyond the scope of this example.) Additionally, you can compute
-// offset outlines (e.g. to stroke the character border inside & outside,
-// or only outside). For example, to fill outside the character up to 3 SDF
-// pixels, you would compare against (180-36.0*3)/255 = 72/255. The above
-// choice of variables maps a range from 5 pixels outside the shape to
-// 2 pixels inside the shape to 0..255; this is intended primarily for apply
-// outside effects only (the interior range is needed to allow proper
-// antialiasing of the font at *smaller* sizes)
-//
-// The function computes the SDF analytically at each SDF pixel, not by e.g.
-// building a higher-res bitmap and approximating it. In theory the quality
-// should be as high as possible for an SDF of this size & representation, but
-// unclear if this is true in practice (perhaps building a higher-res bitmap
-// and computing from that can allow drop-out prevention).
-//
-// The algorithm has not been optimized at all, so expect it to be slow
-// if computing lots of characters or very large sizes.
-
-
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// Finding the right font...
-//
-// You should really just solve this offline, keep your own tables
-// of what font is what, and don't try to get it out of the .ttf file.
-// That's because getting it out of the .ttf file is really hard, because
-// the names in the file can appear in many possible encodings, in many
-// possible languages, and e.g. if you need a case-insensitive comparison,
-// the details of that depend on the encoding & language in a complex way
-// (actually underspecified in truetype, but also gigantic).
-//
-// But you can use the provided functions in two possible ways:
-// stbtt_FindMatchingFont() will use *case-sensitive* comparisons on
-// unicode-encoded names to try to find the font you want;
-// you can run this before calling stbtt_InitFont()
-//
-// stbtt_GetFontNameString() lets you get any of the various strings
-// from the file yourself and do your own comparisons on them.
-// You have to have called stbtt_InitFont() first.
-
-
-STBTT_DEF int stbtt_FindMatchingFont(const unsigned char *fontdata, const char *name, int flags);
-// returns the offset (not index) of the font that matches, or -1 if none
-// if you use STBTT_MACSTYLE_DONTCARE, use a font name like "Arial Bold".
-// if you use any other flag, use a font name like "Arial"; this checks
-// the 'macStyle' header field; i don't know if fonts set this consistently
-#define STBTT_MACSTYLE_DONTCARE 0
-#define STBTT_MACSTYLE_BOLD 1
-#define STBTT_MACSTYLE_ITALIC 2
-#define STBTT_MACSTYLE_UNDERSCORE 4
-#define STBTT_MACSTYLE_NONE 8 // <= not same as 0, this makes us check the bitfield is 0
-
-STBTT_DEF int stbtt_CompareUTF8toUTF16_bigendian(const char *s1, int len1, const char *s2, int len2);
-// returns 1/0 whether the first string interpreted as utf8 is identical to
-// the second string interpreted as big-endian utf16... useful for strings from next func
-
-STBTT_DEF const char *stbtt_GetFontNameString(const stbtt_fontinfo *font, int *length, int platformID, int encodingID, int languageID, int nameID);
-// returns the string (which may be big-endian double byte, e.g. for unicode)
-// and puts the length in bytes in *length.
-//
-// some of the values for the IDs are below; for more see the truetype spec:
-// http://developer.apple.com/textfonts/TTRefMan/RM06/Chap6name.html
-// http://www.microsoft.com/typography/otspec/name.htm
-
-enum { // platformID
- STBTT_PLATFORM_ID_UNICODE =0,
- STBTT_PLATFORM_ID_MAC =1,
- STBTT_PLATFORM_ID_ISO =2,
- STBTT_PLATFORM_ID_MICROSOFT =3
-};
-
-enum { // encodingID for STBTT_PLATFORM_ID_UNICODE
- STBTT_UNICODE_EID_UNICODE_1_0 =0,
- STBTT_UNICODE_EID_UNICODE_1_1 =1,
- STBTT_UNICODE_EID_ISO_10646 =2,
- STBTT_UNICODE_EID_UNICODE_2_0_BMP=3,
- STBTT_UNICODE_EID_UNICODE_2_0_FULL=4
-};
-
-enum { // encodingID for STBTT_PLATFORM_ID_MICROSOFT
- STBTT_MS_EID_SYMBOL =0,
- STBTT_MS_EID_UNICODE_BMP =1,
- STBTT_MS_EID_SHIFTJIS =2,
- STBTT_MS_EID_UNICODE_FULL =10
-};
-
-enum { // encodingID for STBTT_PLATFORM_ID_MAC; same as Script Manager codes
- STBTT_MAC_EID_ROMAN =0, STBTT_MAC_EID_ARABIC =4,
- STBTT_MAC_EID_JAPANESE =1, STBTT_MAC_EID_HEBREW =5,
- STBTT_MAC_EID_CHINESE_TRAD =2, STBTT_MAC_EID_GREEK =6,
- STBTT_MAC_EID_KOREAN =3, STBTT_MAC_EID_RUSSIAN =7
-};
-
-enum { // languageID for STBTT_PLATFORM_ID_MICROSOFT; same as LCID...
- // problematic because there are e.g. 16 english LCIDs and 16 arabic LCIDs
- STBTT_MS_LANG_ENGLISH =0x0409, STBTT_MS_LANG_ITALIAN =0x0410,
- STBTT_MS_LANG_CHINESE =0x0804, STBTT_MS_LANG_JAPANESE =0x0411,
- STBTT_MS_LANG_DUTCH =0x0413, STBTT_MS_LANG_KOREAN =0x0412,
- STBTT_MS_LANG_FRENCH =0x040c, STBTT_MS_LANG_RUSSIAN =0x0419,
- STBTT_MS_LANG_GERMAN =0x0407, STBTT_MS_LANG_SPANISH =0x0409,
- STBTT_MS_LANG_HEBREW =0x040d, STBTT_MS_LANG_SWEDISH =0x041D
-};
-
-enum { // languageID for STBTT_PLATFORM_ID_MAC
- STBTT_MAC_LANG_ENGLISH =0 , STBTT_MAC_LANG_JAPANESE =11,
- STBTT_MAC_LANG_ARABIC =12, STBTT_MAC_LANG_KOREAN =23,
- STBTT_MAC_LANG_DUTCH =4 , STBTT_MAC_LANG_RUSSIAN =32,
- STBTT_MAC_LANG_FRENCH =1 , STBTT_MAC_LANG_SPANISH =6 ,
- STBTT_MAC_LANG_GERMAN =2 , STBTT_MAC_LANG_SWEDISH =5 ,
- STBTT_MAC_LANG_HEBREW =10, STBTT_MAC_LANG_CHINESE_SIMPLIFIED =33,
- STBTT_MAC_LANG_ITALIAN =3 , STBTT_MAC_LANG_CHINESE_TRAD =19
-};
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif // __STB_INCLUDE_STB_TRUETYPE_H__
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-////
-//// IMPLEMENTATION
-////
-////
-
-#ifdef STB_TRUETYPE_IMPLEMENTATION
-
-#ifndef STBTT_MAX_OVERSAMPLE
-#define STBTT_MAX_OVERSAMPLE 8
-#endif
-
-#if STBTT_MAX_OVERSAMPLE > 255
-#error "STBTT_MAX_OVERSAMPLE cannot be > 255"
-#endif
-
-typedef int stbtt__test_oversample_pow2[(STBTT_MAX_OVERSAMPLE & (STBTT_MAX_OVERSAMPLE-1)) == 0 ? 1 : -1];
-
-#ifndef STBTT_RASTERIZER_VERSION
-#define STBTT_RASTERIZER_VERSION 2
-#endif
-
-#ifdef _MSC_VER
-#define STBTT__NOTUSED(v) (void)(v)
-#else
-#define STBTT__NOTUSED(v) (void)sizeof(v)
-#endif
-
-//////////////////////////////////////////////////////////////////////////
-//
-// stbtt__buf helpers to parse data from file
-//
-
-static stbtt_uint8 stbtt__buf_get8(stbtt__buf *b)
-{
- if (b->cursor >= b->size)
- return 0;
- return b->data[b->cursor++];
-}
-
-static stbtt_uint8 stbtt__buf_peek8(stbtt__buf *b)
-{
- if (b->cursor >= b->size)
- return 0;
- return b->data[b->cursor];
-}
-
-static void stbtt__buf_seek(stbtt__buf *b, int o)
-{
- STBTT_assert(!(o > b->size || o < 0));
- b->cursor = (o > b->size || o < 0) ? b->size : o;
-}
-
-static void stbtt__buf_skip(stbtt__buf *b, int o)
-{
- stbtt__buf_seek(b, b->cursor + o);
-}
-
-static stbtt_uint32 stbtt__buf_get(stbtt__buf *b, int n)
-{
- stbtt_uint32 v = 0;
- int i;
- STBTT_assert(n >= 1 && n <= 4);
- for (i = 0; i < n; i++)
- v = (v << 8) | stbtt__buf_get8(b);
- return v;
-}
-
-static stbtt__buf stbtt__new_buf(const void *p, size_t size)
-{
- stbtt__buf r;
- STBTT_assert(size < 0x40000000);
- r.data = (stbtt_uint8*) p;
- r.size = (int) size;
- r.cursor = 0;
- return r;
-}
-
-#define stbtt__buf_get16(b) stbtt__buf_get((b), 2)
-#define stbtt__buf_get32(b) stbtt__buf_get((b), 4)
-
-static stbtt__buf stbtt__buf_range(const stbtt__buf *b, int o, int s)
-{
- stbtt__buf r = stbtt__new_buf(NULL, 0);
- if (o < 0 || s < 0 || o > b->size || s > b->size - o) return r;
- r.data = b->data + o;
- r.size = s;
- return r;
-}
-
-static stbtt__buf stbtt__cff_get_index(stbtt__buf *b)
-{
- int count, start, offsize;
- start = b->cursor;
- count = stbtt__buf_get16(b);
- if (count) {
- offsize = stbtt__buf_get8(b);
- STBTT_assert(offsize >= 1 && offsize <= 4);
- stbtt__buf_skip(b, offsize * count);
- stbtt__buf_skip(b, stbtt__buf_get(b, offsize) - 1);
- }
- return stbtt__buf_range(b, start, b->cursor - start);
-}
-
-static stbtt_uint32 stbtt__cff_int(stbtt__buf *b)
-{
- int b0 = stbtt__buf_get8(b);
- if (b0 >= 32 && b0 <= 246) return b0 - 139;
- else if (b0 >= 247 && b0 <= 250) return (b0 - 247)*256 + stbtt__buf_get8(b) + 108;
- else if (b0 >= 251 && b0 <= 254) return -(b0 - 251)*256 - stbtt__buf_get8(b) - 108;
- else if (b0 == 28) return stbtt__buf_get16(b);
- else if (b0 == 29) return stbtt__buf_get32(b);
- STBTT_assert(0);
- return 0;
-}
-
-static void stbtt__cff_skip_operand(stbtt__buf *b) {
- int v, b0 = stbtt__buf_peek8(b);
- STBTT_assert(b0 >= 28);
- if (b0 == 30) {
- stbtt__buf_skip(b, 1);
- while (b->cursor < b->size) {
- v = stbtt__buf_get8(b);
- if ((v & 0xF) == 0xF || (v >> 4) == 0xF)
- break;
- }
- } else {
- stbtt__cff_int(b);
- }
-}
-
-static stbtt__buf stbtt__dict_get(stbtt__buf *b, int key)
-{
- stbtt__buf_seek(b, 0);
- while (b->cursor < b->size) {
- int start = b->cursor, end, op;
- while (stbtt__buf_peek8(b) >= 28)
- stbtt__cff_skip_operand(b);
- end = b->cursor;
- op = stbtt__buf_get8(b);
- if (op == 12) op = stbtt__buf_get8(b) | 0x100;
- if (op == key) return stbtt__buf_range(b, start, end-start);
- }
- return stbtt__buf_range(b, 0, 0);
-}
-
-static void stbtt__dict_get_ints(stbtt__buf *b, int key, int outcount, stbtt_uint32 *out)
-{
- int i;
- stbtt__buf operands = stbtt__dict_get(b, key);
- for (i = 0; i < outcount && operands.cursor < operands.size; i++)
- out[i] = stbtt__cff_int(&operands);
-}
-
-static int stbtt__cff_index_count(stbtt__buf *b)
-{
- stbtt__buf_seek(b, 0);
- return stbtt__buf_get16(b);
-}
-
-static stbtt__buf stbtt__cff_index_get(stbtt__buf b, int i)
-{
- int count, offsize, start, end;
- stbtt__buf_seek(&b, 0);
- count = stbtt__buf_get16(&b);
- offsize = stbtt__buf_get8(&b);
- STBTT_assert(i >= 0 && i < count);
- STBTT_assert(offsize >= 1 && offsize <= 4);
- stbtt__buf_skip(&b, i*offsize);
- start = stbtt__buf_get(&b, offsize);
- end = stbtt__buf_get(&b, offsize);
- return stbtt__buf_range(&b, 2+(count+1)*offsize+start, end - start);
-}
-
-//////////////////////////////////////////////////////////////////////////
-//
-// accessors to parse data from file
-//
-
-// on platforms that don't allow misaligned reads, if we want to allow
-// truetype fonts that aren't padded to alignment, define ALLOW_UNALIGNED_TRUETYPE
-
-#define ttBYTE(p) (* (stbtt_uint8 *) (p))
-#define ttCHAR(p) (* (stbtt_int8 *) (p))
-#define ttFixed(p) ttLONG(p)
-
-static stbtt_uint16 ttUSHORT(stbtt_uint8 *p) { return p[0]*256 + p[1]; }
-static stbtt_int16 ttSHORT(stbtt_uint8 *p) { return p[0]*256 + p[1]; }
-static stbtt_uint32 ttULONG(stbtt_uint8 *p) { return (p[0]<<24) + (p[1]<<16) + (p[2]<<8) + p[3]; }
-static stbtt_int32 ttLONG(stbtt_uint8 *p) { return (p[0]<<24) + (p[1]<<16) + (p[2]<<8) + p[3]; }
-
-#define stbtt_tag4(p,c0,c1,c2,c3) ((p)[0] == (c0) && (p)[1] == (c1) && (p)[2] == (c2) && (p)[3] == (c3))
-#define stbtt_tag(p,str) stbtt_tag4(p,str[0],str[1],str[2],str[3])
-
-static int stbtt__isfont(stbtt_uint8 *font)
-{
- // check the version number
- if (stbtt_tag4(font, '1',0,0,0)) return 1; // TrueType 1
- if (stbtt_tag(font, "typ1")) return 1; // TrueType with type 1 font -- we don't support this!
- if (stbtt_tag(font, "OTTO")) return 1; // OpenType with CFF
- if (stbtt_tag4(font, 0,1,0,0)) return 1; // OpenType 1.0
- if (stbtt_tag(font, "true")) return 1; // Apple specification for TrueType fonts
- return 0;
-}
-
-// @OPTIMIZE: binary search
-static stbtt_uint32 stbtt__find_table(stbtt_uint8 *data, stbtt_uint32 fontstart, const char *tag)
-{
- stbtt_int32 num_tables = ttUSHORT(data+fontstart+4);
- stbtt_uint32 tabledir = fontstart + 12;
- stbtt_int32 i;
- for (i=0; i < num_tables; ++i) {
- stbtt_uint32 loc = tabledir + 16*i;
- if (stbtt_tag(data+loc+0, tag))
- return ttULONG(data+loc+8);
- }
- return 0;
-}
-
-static int stbtt_GetFontOffsetForIndex_internal(unsigned char *font_collection, int index)
-{
- // if it's just a font, there's only one valid index
- if (stbtt__isfont(font_collection))
- return index == 0 ? 0 : -1;
-
- // check if it's a TTC
- if (stbtt_tag(font_collection, "ttcf")) {
- // version 1?
- if (ttULONG(font_collection+4) == 0x00010000 || ttULONG(font_collection+4) == 0x00020000) {
- stbtt_int32 n = ttLONG(font_collection+8);
- if (index >= n)
- return -1;
- return ttULONG(font_collection+12+index*4);
- }
- }
- return -1;
-}
-
-static int stbtt_GetNumberOfFonts_internal(unsigned char *font_collection)
-{
- // if it's just a font, there's only one valid font
- if (stbtt__isfont(font_collection))
- return 1;
-
- // check if it's a TTC
- if (stbtt_tag(font_collection, "ttcf")) {
- // version 1?
- if (ttULONG(font_collection+4) == 0x00010000 || ttULONG(font_collection+4) == 0x00020000) {
- return ttLONG(font_collection+8);
- }
- }
- return 0;
-}
-
-static stbtt__buf stbtt__get_subrs(stbtt__buf cff, stbtt__buf fontdict)
-{
- stbtt_uint32 subrsoff = 0, private_loc[2] = { 0, 0 };
- stbtt__buf pdict;
- stbtt__dict_get_ints(&fontdict, 18, 2, private_loc);
- if (!private_loc[1] || !private_loc[0]) return stbtt__new_buf(NULL, 0);
- pdict = stbtt__buf_range(&cff, private_loc[1], private_loc[0]);
- stbtt__dict_get_ints(&pdict, 19, 1, &subrsoff);
- if (!subrsoff) return stbtt__new_buf(NULL, 0);
- stbtt__buf_seek(&cff, private_loc[1]+subrsoff);
- return stbtt__cff_get_index(&cff);
-}
-
-// since most people won't use this, find this table the first time it's needed
-static int stbtt__get_svg(stbtt_fontinfo *info)
-{
- stbtt_uint32 t;
- if (info->svg < 0) {
- t = stbtt__find_table(info->data, info->fontstart, "SVG ");
- if (t) {
- stbtt_uint32 offset = ttULONG(info->data + t + 2);
- info->svg = t + offset;
- } else {
- info->svg = 0;
- }
- }
- return info->svg;
-}
-
-static int stbtt_InitFont_internal(stbtt_fontinfo *info, unsigned char *data, int fontstart)
-{
- stbtt_uint32 cmap, t;
- stbtt_int32 i,numTables;
-
- info->data = data;
- info->fontstart = fontstart;
- info->cff = stbtt__new_buf(NULL, 0);
-
- cmap = stbtt__find_table(data, fontstart, "cmap"); // required
- info->loca = stbtt__find_table(data, fontstart, "loca"); // required
- info->head = stbtt__find_table(data, fontstart, "head"); // required
- info->glyf = stbtt__find_table(data, fontstart, "glyf"); // required
- info->hhea = stbtt__find_table(data, fontstart, "hhea"); // required
- info->hmtx = stbtt__find_table(data, fontstart, "hmtx"); // required
- info->kern = stbtt__find_table(data, fontstart, "kern"); // not required
- info->gpos = stbtt__find_table(data, fontstart, "GPOS"); // not required
-
- if (!cmap || !info->head || !info->hhea || !info->hmtx)
- return 0;
- if (info->glyf) {
- // required for truetype
- if (!info->loca) return 0;
- } else {
- // initialization for CFF / Type2 fonts (OTF)
- stbtt__buf b, topdict, topdictidx;
- stbtt_uint32 cstype = 2, charstrings = 0, fdarrayoff = 0, fdselectoff = 0;
- stbtt_uint32 cff;
-
- cff = stbtt__find_table(data, fontstart, "CFF ");
- if (!cff) return 0;
-
- info->fontdicts = stbtt__new_buf(NULL, 0);
- info->fdselect = stbtt__new_buf(NULL, 0);
-
- // @TODO this should use size from table (not 512MB)
- info->cff = stbtt__new_buf(data+cff, 512*1024*1024);
- b = info->cff;
-
- // read the header
- stbtt__buf_skip(&b, 2);
- stbtt__buf_seek(&b, stbtt__buf_get8(&b)); // hdrsize
-
- // @TODO the name INDEX could list multiple fonts,
- // but we just use the first one.
- stbtt__cff_get_index(&b); // name INDEX
- topdictidx = stbtt__cff_get_index(&b);
- topdict = stbtt__cff_index_get(topdictidx, 0);
- stbtt__cff_get_index(&b); // string INDEX
- info->gsubrs = stbtt__cff_get_index(&b);
-
- stbtt__dict_get_ints(&topdict, 17, 1, &charstrings);
- stbtt__dict_get_ints(&topdict, 0x100 | 6, 1, &cstype);
- stbtt__dict_get_ints(&topdict, 0x100 | 36, 1, &fdarrayoff);
- stbtt__dict_get_ints(&topdict, 0x100 | 37, 1, &fdselectoff);
- info->subrs = stbtt__get_subrs(b, topdict);
-
- // we only support Type 2 charstrings
- if (cstype != 2) return 0;
- if (charstrings == 0) return 0;
-
- if (fdarrayoff) {
- // looks like a CID font
- if (!fdselectoff) return 0;
- stbtt__buf_seek(&b, fdarrayoff);
- info->fontdicts = stbtt__cff_get_index(&b);
- info->fdselect = stbtt__buf_range(&b, fdselectoff, b.size-fdselectoff);
- }
-
- stbtt__buf_seek(&b, charstrings);
- info->charstrings = stbtt__cff_get_index(&b);
- }
-
- t = stbtt__find_table(data, fontstart, "maxp");
- if (t)
- info->numGlyphs = ttUSHORT(data+t+4);
- else
- info->numGlyphs = 0xffff;
-
- info->svg = -1;
-
- // find a cmap encoding table we understand *now* to avoid searching
- // later. (todo: could make this installable)
- // the same regardless of glyph.
- numTables = ttUSHORT(data + cmap + 2);
- info->index_map = 0;
- for (i=0; i < numTables; ++i) {
- stbtt_uint32 encoding_record = cmap + 4 + 8 * i;
- // find an encoding we understand:
- switch(ttUSHORT(data+encoding_record)) {
- case STBTT_PLATFORM_ID_MICROSOFT:
- switch (ttUSHORT(data+encoding_record+2)) {
- case STBTT_MS_EID_UNICODE_BMP:
- case STBTT_MS_EID_UNICODE_FULL:
- // MS/Unicode
- info->index_map = cmap + ttULONG(data+encoding_record+4);
- break;
- }
- break;
- case STBTT_PLATFORM_ID_UNICODE:
- // Mac/iOS has these
- // all the encodingIDs are unicode, so we don't bother to check it
- info->index_map = cmap + ttULONG(data+encoding_record+4);
- break;
- }
- }
- if (info->index_map == 0)
- return 0;
-
- info->indexToLocFormat = ttUSHORT(data+info->head + 50);
- return 1;
-}
-
-STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codepoint)
-{
- stbtt_uint8 *data = info->data;
- stbtt_uint32 index_map = info->index_map;
-
- stbtt_uint16 format = ttUSHORT(data + index_map + 0);
- if (format == 0) { // apple byte encoding
- stbtt_int32 bytes = ttUSHORT(data + index_map + 2);
- if (unicode_codepoint < bytes-6)
- return ttBYTE(data + index_map + 6 + unicode_codepoint);
- return 0;
- } else if (format == 6) {
- stbtt_uint32 first = ttUSHORT(data + index_map + 6);
- stbtt_uint32 count = ttUSHORT(data + index_map + 8);
- if ((stbtt_uint32) unicode_codepoint >= first && (stbtt_uint32) unicode_codepoint < first+count)
- return ttUSHORT(data + index_map + 10 + (unicode_codepoint - first)*2);
- return 0;
- } else if (format == 2) {
- STBTT_assert(0); // @TODO: high-byte mapping for japanese/chinese/korean
- return 0;
- } else if (format == 4) { // standard mapping for windows fonts: binary search collection of ranges
- stbtt_uint16 segcount = ttUSHORT(data+index_map+6) >> 1;
- stbtt_uint16 searchRange = ttUSHORT(data+index_map+8) >> 1;
- stbtt_uint16 entrySelector = ttUSHORT(data+index_map+10);
- stbtt_uint16 rangeShift = ttUSHORT(data+index_map+12) >> 1;
-
- // do a binary search of the segments
- stbtt_uint32 endCount = index_map + 14;
- stbtt_uint32 search = endCount;
-
- if (unicode_codepoint > 0xffff)
- return 0;
-
- // they lie from endCount .. endCount + segCount
- // but searchRange is the nearest power of two, so...
- if (unicode_codepoint >= ttUSHORT(data + search + rangeShift*2))
- search += rangeShift*2;
-
- // now decrement to bias correctly to find smallest
- search -= 2;
- while (entrySelector) {
- stbtt_uint16 end;
- searchRange >>= 1;
- end = ttUSHORT(data + search + searchRange*2);
- if (unicode_codepoint > end)
- search += searchRange*2;
- --entrySelector;
- }
- search += 2;
-
- {
- stbtt_uint16 offset, start, last;
- stbtt_uint16 item = (stbtt_uint16) ((search - endCount) >> 1);
-
- start = ttUSHORT(data + index_map + 14 + segcount*2 + 2 + 2*item);
- last = ttUSHORT(data + endCount + 2*item);
- if (unicode_codepoint < start || unicode_codepoint > last)
- return 0;
-
- offset = ttUSHORT(data + index_map + 14 + segcount*6 + 2 + 2*item);
- if (offset == 0)
- return (stbtt_uint16) (unicode_codepoint + ttSHORT(data + index_map + 14 + segcount*4 + 2 + 2*item));
-
- return ttUSHORT(data + offset + (unicode_codepoint-start)*2 + index_map + 14 + segcount*6 + 2 + 2*item);
- }
- } else if (format == 12 || format == 13) {
- stbtt_uint32 ngroups = ttULONG(data+index_map+12);
- stbtt_int32 low,high;
- low = 0; high = (stbtt_int32)ngroups;
- // Binary search the right group.
- while (low < high) {
- stbtt_int32 mid = low + ((high-low) >> 1); // rounds down, so low <= mid < high
- stbtt_uint32 start_char = ttULONG(data+index_map+16+mid*12);
- stbtt_uint32 end_char = ttULONG(data+index_map+16+mid*12+4);
- if ((stbtt_uint32) unicode_codepoint < start_char)
- high = mid;
- else if ((stbtt_uint32) unicode_codepoint > end_char)
- low = mid+1;
- else {
- stbtt_uint32 start_glyph = ttULONG(data+index_map+16+mid*12+8);
- if (format == 12)
- return start_glyph + unicode_codepoint-start_char;
- else // format == 13
- return start_glyph;
- }
- }
- return 0; // not found
- }
- // @TODO
- STBTT_assert(0);
- return 0;
-}
-
-STBTT_DEF int stbtt_GetCodepointShape(const stbtt_fontinfo *info, int unicode_codepoint, stbtt_vertex **vertices)
-{
- return stbtt_GetGlyphShape(info, stbtt_FindGlyphIndex(info, unicode_codepoint), vertices);
-}
-
-static void stbtt_setvertex(stbtt_vertex *v, stbtt_uint8 type, stbtt_int32 x, stbtt_int32 y, stbtt_int32 cx, stbtt_int32 cy)
-{
- v->type = type;
- v->x = (stbtt_int16) x;
- v->y = (stbtt_int16) y;
- v->cx = (stbtt_int16) cx;
- v->cy = (stbtt_int16) cy;
-}
-
-static int stbtt__GetGlyfOffset(const stbtt_fontinfo *info, int glyph_index)
-{
- int g1,g2;
-
- STBTT_assert(!info->cff.size);
-
- if (glyph_index >= info->numGlyphs) return -1; // glyph index out of range
- if (info->indexToLocFormat >= 2) return -1; // unknown index->glyph map format
-
- if (info->indexToLocFormat == 0) {
- g1 = info->glyf + ttUSHORT(info->data + info->loca + glyph_index * 2) * 2;
- g2 = info->glyf + ttUSHORT(info->data + info->loca + glyph_index * 2 + 2) * 2;
- } else {
- g1 = info->glyf + ttULONG (info->data + info->loca + glyph_index * 4);
- g2 = info->glyf + ttULONG (info->data + info->loca + glyph_index * 4 + 4);
- }
-
- return g1==g2 ? -1 : g1; // if length is 0, return -1
-}
-
-static int stbtt__GetGlyphInfoT2(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1);
-
-STBTT_DEF int stbtt_GetGlyphBox(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1)
-{
- if (info->cff.size) {
- stbtt__GetGlyphInfoT2(info, glyph_index, x0, y0, x1, y1);
- } else {
- int g = stbtt__GetGlyfOffset(info, glyph_index);
- if (g < 0) return 0;
-
- if (x0) *x0 = ttSHORT(info->data + g + 2);
- if (y0) *y0 = ttSHORT(info->data + g + 4);
- if (x1) *x1 = ttSHORT(info->data + g + 6);
- if (y1) *y1 = ttSHORT(info->data + g + 8);
- }
- return 1;
-}
-
-STBTT_DEF int stbtt_GetCodepointBox(const stbtt_fontinfo *info, int codepoint, int *x0, int *y0, int *x1, int *y1)
-{
- return stbtt_GetGlyphBox(info, stbtt_FindGlyphIndex(info,codepoint), x0,y0,x1,y1);
-}
-
-STBTT_DEF int stbtt_IsGlyphEmpty(const stbtt_fontinfo *info, int glyph_index)
-{
- stbtt_int16 numberOfContours;
- int g;
- if (info->cff.size)
- return stbtt__GetGlyphInfoT2(info, glyph_index, NULL, NULL, NULL, NULL) == 0;
- g = stbtt__GetGlyfOffset(info, glyph_index);
- if (g < 0) return 1;
- numberOfContours = ttSHORT(info->data + g);
- return numberOfContours == 0;
-}
-
-static int stbtt__close_shape(stbtt_vertex *vertices, int num_vertices, int was_off, int start_off,
- stbtt_int32 sx, stbtt_int32 sy, stbtt_int32 scx, stbtt_int32 scy, stbtt_int32 cx, stbtt_int32 cy)
-{
- if (start_off) {
- if (was_off)
- stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, (cx+scx)>>1, (cy+scy)>>1, cx,cy);
- stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, sx,sy,scx,scy);
- } else {
- if (was_off)
- stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve,sx,sy,cx,cy);
- else
- stbtt_setvertex(&vertices[num_vertices++], STBTT_vline,sx,sy,0,0);
- }
- return num_vertices;
-}
-
-static int stbtt__GetGlyphShapeTT(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices)
-{
- stbtt_int16 numberOfContours;
- stbtt_uint8 *endPtsOfContours;
- stbtt_uint8 *data = info->data;
- stbtt_vertex *vertices=0;
- int num_vertices=0;
- int g = stbtt__GetGlyfOffset(info, glyph_index);
-
- *pvertices = NULL;
-
- if (g < 0) return 0;
-
- numberOfContours = ttSHORT(data + g);
-
- if (numberOfContours > 0) {
- stbtt_uint8 flags=0,flagcount;
- stbtt_int32 ins, i,j=0,m,n, next_move, was_off=0, off, start_off=0;
- stbtt_int32 x,y,cx,cy,sx,sy, scx,scy;
- stbtt_uint8 *points;
- endPtsOfContours = (data + g + 10);
- ins = ttUSHORT(data + g + 10 + numberOfContours * 2);
- points = data + g + 10 + numberOfContours * 2 + 2 + ins;
-
- n = 1+ttUSHORT(endPtsOfContours + numberOfContours*2-2);
-
- m = n + 2*numberOfContours; // a loose bound on how many vertices we might need
- vertices = (stbtt_vertex *) STBTT_malloc(m * sizeof(vertices[0]), info->userdata);
- if (vertices == 0)
- return 0;
-
- next_move = 0;
- flagcount=0;
-
- // in first pass, we load uninterpreted data into the allocated array
- // above, shifted to the end of the array so we won't overwrite it when
- // we create our final data starting from the front
-
- off = m - n; // starting offset for uninterpreted data, regardless of how m ends up being calculated
-
- // first load flags
-
- for (i=0; i < n; ++i) {
- if (flagcount == 0) {
- flags = *points++;
- if (flags & 8)
- flagcount = *points++;
- } else
- --flagcount;
- vertices[off+i].type = flags;
- }
-
- // now load x coordinates
- x=0;
- for (i=0; i < n; ++i) {
- flags = vertices[off+i].type;
- if (flags & 2) {
- stbtt_int16 dx = *points++;
- x += (flags & 16) ? dx : -dx; // ???
- } else {
- if (!(flags & 16)) {
- x = x + (stbtt_int16) (points[0]*256 + points[1]);
- points += 2;
- }
- }
- vertices[off+i].x = (stbtt_int16) x;
- }
-
- // now load y coordinates
- y=0;
- for (i=0; i < n; ++i) {
- flags = vertices[off+i].type;
- if (flags & 4) {
- stbtt_int16 dy = *points++;
- y += (flags & 32) ? dy : -dy; // ???
- } else {
- if (!(flags & 32)) {
- y = y + (stbtt_int16) (points[0]*256 + points[1]);
- points += 2;
- }
- }
- vertices[off+i].y = (stbtt_int16) y;
- }
-
- // now convert them to our format
- num_vertices=0;
- sx = sy = cx = cy = scx = scy = 0;
- for (i=0; i < n; ++i) {
- flags = vertices[off+i].type;
- x = (stbtt_int16) vertices[off+i].x;
- y = (stbtt_int16) vertices[off+i].y;
-
- if (next_move == i) {
- if (i != 0)
- num_vertices = stbtt__close_shape(vertices, num_vertices, was_off, start_off, sx,sy,scx,scy,cx,cy);
-
- // now start the new one
- start_off = !(flags & 1);
- if (start_off) {
- // if we start off with an off-curve point, then when we need to find a point on the curve
- // where we can start, and we need to save some state for when we wraparound.
- scx = x;
- scy = y;
- if (!(vertices[off+i+1].type & 1)) {
- // next point is also a curve point, so interpolate an on-point curve
- sx = (x + (stbtt_int32) vertices[off+i+1].x) >> 1;
- sy = (y + (stbtt_int32) vertices[off+i+1].y) >> 1;
- } else {
- // otherwise just use the next point as our start point
- sx = (stbtt_int32) vertices[off+i+1].x;
- sy = (stbtt_int32) vertices[off+i+1].y;
- ++i; // we're using point i+1 as the starting point, so skip it
- }
- } else {
- sx = x;
- sy = y;
- }
- stbtt_setvertex(&vertices[num_vertices++], STBTT_vmove,sx,sy,0,0);
- was_off = 0;
- next_move = 1 + ttUSHORT(endPtsOfContours+j*2);
- ++j;
- } else {
- if (!(flags & 1)) { // if it's a curve
- if (was_off) // two off-curve control points in a row means interpolate an on-curve midpoint
- stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, (cx+x)>>1, (cy+y)>>1, cx, cy);
- cx = x;
- cy = y;
- was_off = 1;
- } else {
- if (was_off)
- stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, x,y, cx, cy);
- else
- stbtt_setvertex(&vertices[num_vertices++], STBTT_vline, x,y,0,0);
- was_off = 0;
- }
- }
- }
- num_vertices = stbtt__close_shape(vertices, num_vertices, was_off, start_off, sx,sy,scx,scy,cx,cy);
- } else if (numberOfContours < 0) {
- // Compound shapes.
- int more = 1;
- stbtt_uint8 *comp = data + g + 10;
- num_vertices = 0;
- vertices = 0;
- while (more) {
- stbtt_uint16 flags, gidx;
- int comp_num_verts = 0, i;
- stbtt_vertex *comp_verts = 0, *tmp = 0;
- float mtx[6] = {1,0,0,1,0,0}, m, n;
-
- flags = ttSHORT(comp); comp+=2;
- gidx = ttSHORT(comp); comp+=2;
-
- if (flags & 2) { // XY values
- if (flags & 1) { // shorts
- mtx[4] = ttSHORT(comp); comp+=2;
- mtx[5] = ttSHORT(comp); comp+=2;
- } else {
- mtx[4] = ttCHAR(comp); comp+=1;
- mtx[5] = ttCHAR(comp); comp+=1;
- }
- }
- else {
- // @TODO handle matching point
- STBTT_assert(0);
- }
- if (flags & (1<<3)) { // WE_HAVE_A_SCALE
- mtx[0] = mtx[3] = ttSHORT(comp)/16384.0f; comp+=2;
- mtx[1] = mtx[2] = 0;
- } else if (flags & (1<<6)) { // WE_HAVE_AN_X_AND_YSCALE
- mtx[0] = ttSHORT(comp)/16384.0f; comp+=2;
- mtx[1] = mtx[2] = 0;
- mtx[3] = ttSHORT(comp)/16384.0f; comp+=2;
- } else if (flags & (1<<7)) { // WE_HAVE_A_TWO_BY_TWO
- mtx[0] = ttSHORT(comp)/16384.0f; comp+=2;
- mtx[1] = ttSHORT(comp)/16384.0f; comp+=2;
- mtx[2] = ttSHORT(comp)/16384.0f; comp+=2;
- mtx[3] = ttSHORT(comp)/16384.0f; comp+=2;
- }
-
- // Find transformation scales.
- m = (float) STBTT_sqrt(mtx[0]*mtx[0] + mtx[1]*mtx[1]);
- n = (float) STBTT_sqrt(mtx[2]*mtx[2] + mtx[3]*mtx[3]);
-
- // Get indexed glyph.
- comp_num_verts = stbtt_GetGlyphShape(info, gidx, &comp_verts);
- if (comp_num_verts > 0) {
- // Transform vertices.
- for (i = 0; i < comp_num_verts; ++i) {
- stbtt_vertex* v = &comp_verts[i];
- stbtt_vertex_type x,y;
- x=v->x; y=v->y;
- v->x = (stbtt_vertex_type)(m * (mtx[0]*x + mtx[2]*y + mtx[4]));
- v->y = (stbtt_vertex_type)(n * (mtx[1]*x + mtx[3]*y + mtx[5]));
- x=v->cx; y=v->cy;
- v->cx = (stbtt_vertex_type)(m * (mtx[0]*x + mtx[2]*y + mtx[4]));
- v->cy = (stbtt_vertex_type)(n * (mtx[1]*x + mtx[3]*y + mtx[5]));
- }
- // Append vertices.
- tmp = (stbtt_vertex*)STBTT_malloc((num_vertices+comp_num_verts)*sizeof(stbtt_vertex), info->userdata);
- if (!tmp) {
- if (vertices) STBTT_free(vertices, info->userdata);
- if (comp_verts) STBTT_free(comp_verts, info->userdata);
- return 0;
- }
- if (num_vertices > 0 && vertices) STBTT_memcpy(tmp, vertices, num_vertices*sizeof(stbtt_vertex));
- STBTT_memcpy(tmp+num_vertices, comp_verts, comp_num_verts*sizeof(stbtt_vertex));
- if (vertices) STBTT_free(vertices, info->userdata);
- vertices = tmp;
- STBTT_free(comp_verts, info->userdata);
- num_vertices += comp_num_verts;
- }
- // More components ?
- more = flags & (1<<5);
- }
- } else {
- // numberOfCounters == 0, do nothing
- }
-
- *pvertices = vertices;
- return num_vertices;
-}
-
-typedef struct
-{
- int bounds;
- int started;
- float first_x, first_y;
- float x, y;
- stbtt_int32 min_x, max_x, min_y, max_y;
-
- stbtt_vertex *pvertices;
- int num_vertices;
-} stbtt__csctx;
-
-#define STBTT__CSCTX_INIT(bounds) {bounds,0, 0,0, 0,0, 0,0,0,0, NULL, 0}
-
-static void stbtt__track_vertex(stbtt__csctx *c, stbtt_int32 x, stbtt_int32 y)
-{
- if (x > c->max_x || !c->started) c->max_x = x;
- if (y > c->max_y || !c->started) c->max_y = y;
- if (x < c->min_x || !c->started) c->min_x = x;
- if (y < c->min_y || !c->started) c->min_y = y;
- c->started = 1;
-}
-
-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)
-{
- if (c->bounds) {
- stbtt__track_vertex(c, x, y);
- if (type == STBTT_vcubic) {
- stbtt__track_vertex(c, cx, cy);
- stbtt__track_vertex(c, cx1, cy1);
- }
- } else {
- stbtt_setvertex(&c->pvertices[c->num_vertices], type, x, y, cx, cy);
- c->pvertices[c->num_vertices].cx1 = (stbtt_int16) cx1;
- c->pvertices[c->num_vertices].cy1 = (stbtt_int16) cy1;
- }
- c->num_vertices++;
-}
-
-static void stbtt__csctx_close_shape(stbtt__csctx *ctx)
-{
- if (ctx->first_x != ctx->x || ctx->first_y != ctx->y)
- stbtt__csctx_v(ctx, STBTT_vline, (int)ctx->first_x, (int)ctx->first_y, 0, 0, 0, 0);
-}
-
-static void stbtt__csctx_rmove_to(stbtt__csctx *ctx, float dx, float dy)
-{
- stbtt__csctx_close_shape(ctx);
- ctx->first_x = ctx->x = ctx->x + dx;
- ctx->first_y = ctx->y = ctx->y + dy;
- stbtt__csctx_v(ctx, STBTT_vmove, (int)ctx->x, (int)ctx->y, 0, 0, 0, 0);
-}
-
-static void stbtt__csctx_rline_to(stbtt__csctx *ctx, float dx, float dy)
-{
- ctx->x += dx;
- ctx->y += dy;
- stbtt__csctx_v(ctx, STBTT_vline, (int)ctx->x, (int)ctx->y, 0, 0, 0, 0);
-}
-
-static void stbtt__csctx_rccurve_to(stbtt__csctx *ctx, float dx1, float dy1, float dx2, float dy2, float dx3, float dy3)
-{
- float cx1 = ctx->x + dx1;
- float cy1 = ctx->y + dy1;
- float cx2 = cx1 + dx2;
- float cy2 = cy1 + dy2;
- ctx->x = cx2 + dx3;
- ctx->y = cy2 + dy3;
- stbtt__csctx_v(ctx, STBTT_vcubic, (int)ctx->x, (int)ctx->y, (int)cx1, (int)cy1, (int)cx2, (int)cy2);
-}
-
-static stbtt__buf stbtt__get_subr(stbtt__buf idx, int n)
-{
- int count = stbtt__cff_index_count(&idx);
- int bias = 107;
- if (count >= 33900)
- bias = 32768;
- else if (count >= 1240)
- bias = 1131;
- n += bias;
- if (n < 0 || n >= count)
- return stbtt__new_buf(NULL, 0);
- return stbtt__cff_index_get(idx, n);
-}
-
-static stbtt__buf stbtt__cid_get_glyph_subrs(const stbtt_fontinfo *info, int glyph_index)
-{
- stbtt__buf fdselect = info->fdselect;
- int nranges, start, end, v, fmt, fdselector = -1, i;
-
- stbtt__buf_seek(&fdselect, 0);
- fmt = stbtt__buf_get8(&fdselect);
- if (fmt == 0) {
- // untested
- stbtt__buf_skip(&fdselect, glyph_index);
- fdselector = stbtt__buf_get8(&fdselect);
- } else if (fmt == 3) {
- nranges = stbtt__buf_get16(&fdselect);
- start = stbtt__buf_get16(&fdselect);
- for (i = 0; i < nranges; i++) {
- v = stbtt__buf_get8(&fdselect);
- end = stbtt__buf_get16(&fdselect);
- if (glyph_index >= start && glyph_index < end) {
- fdselector = v;
- break;
- }
- start = end;
- }
- }
- if (fdselector == -1) stbtt__new_buf(NULL, 0);
- return stbtt__get_subrs(info->cff, stbtt__cff_index_get(info->fontdicts, fdselector));
-}
-
-static int stbtt__run_charstring(const stbtt_fontinfo *info, int glyph_index, stbtt__csctx *c)
-{
- int in_header = 1, maskbits = 0, subr_stack_height = 0, sp = 0, v, i, b0;
- int has_subrs = 0, clear_stack;
- float s[48];
- stbtt__buf subr_stack[10], subrs = info->subrs, b;
- float f;
-
-#define STBTT__CSERR(s) (0)
-
- // this currently ignores the initial width value, which isn't needed if we have hmtx
- b = stbtt__cff_index_get(info->charstrings, glyph_index);
- while (b.cursor < b.size) {
- i = 0;
- clear_stack = 1;
- b0 = stbtt__buf_get8(&b);
- switch (b0) {
- // @TODO implement hinting
- case 0x13: // hintmask
- case 0x14: // cntrmask
- if (in_header)
- maskbits += (sp / 2); // implicit "vstem"
- in_header = 0;
- stbtt__buf_skip(&b, (maskbits + 7) / 8);
- break;
-
- case 0x01: // hstem
- case 0x03: // vstem
- case 0x12: // hstemhm
- case 0x17: // vstemhm
- maskbits += (sp / 2);
- break;
-
- case 0x15: // rmoveto
- in_header = 0;
- if (sp < 2) return STBTT__CSERR("rmoveto stack");
- stbtt__csctx_rmove_to(c, s[sp-2], s[sp-1]);
- break;
- case 0x04: // vmoveto
- in_header = 0;
- if (sp < 1) return STBTT__CSERR("vmoveto stack");
- stbtt__csctx_rmove_to(c, 0, s[sp-1]);
- break;
- case 0x16: // hmoveto
- in_header = 0;
- if (sp < 1) return STBTT__CSERR("hmoveto stack");
- stbtt__csctx_rmove_to(c, s[sp-1], 0);
- break;
-
- case 0x05: // rlineto
- if (sp < 2) return STBTT__CSERR("rlineto stack");
- for (; i + 1 < sp; i += 2)
- stbtt__csctx_rline_to(c, s[i], s[i+1]);
- break;
-
- // hlineto/vlineto and vhcurveto/hvcurveto alternate horizontal and vertical
- // starting from a different place.
-
- case 0x07: // vlineto
- if (sp < 1) return STBTT__CSERR("vlineto stack");
- goto vlineto;
- case 0x06: // hlineto
- if (sp < 1) return STBTT__CSERR("hlineto stack");
- for (;;) {
- if (i >= sp) break;
- stbtt__csctx_rline_to(c, s[i], 0);
- i++;
- vlineto:
- if (i >= sp) break;
- stbtt__csctx_rline_to(c, 0, s[i]);
- i++;
- }
- break;
-
- case 0x1F: // hvcurveto
- if (sp < 4) return STBTT__CSERR("hvcurveto stack");
- goto hvcurveto;
- case 0x1E: // vhcurveto
- if (sp < 4) return STBTT__CSERR("vhcurveto stack");
- for (;;) {
- if (i + 3 >= sp) break;
- 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);
- i += 4;
- hvcurveto:
- if (i + 3 >= sp) break;
- 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]);
- i += 4;
- }
- break;
-
- case 0x08: // rrcurveto
- if (sp < 6) return STBTT__CSERR("rcurveline stack");
- for (; i + 5 < sp; i += 6)
- stbtt__csctx_rccurve_to(c, s[i], s[i+1], s[i+2], s[i+3], s[i+4], s[i+5]);
- break;
-
- case 0x18: // rcurveline
- if (sp < 8) return STBTT__CSERR("rcurveline stack");
- for (; i + 5 < sp - 2; i += 6)
- stbtt__csctx_rccurve_to(c, s[i], s[i+1], s[i+2], s[i+3], s[i+4], s[i+5]);
- if (i + 1 >= sp) return STBTT__CSERR("rcurveline stack");
- stbtt__csctx_rline_to(c, s[i], s[i+1]);
- break;
-
- case 0x19: // rlinecurve
- if (sp < 8) return STBTT__CSERR("rlinecurve stack");
- for (; i + 1 < sp - 6; i += 2)
- stbtt__csctx_rline_to(c, s[i], s[i+1]);
- if (i + 5 >= sp) return STBTT__CSERR("rlinecurve stack");
- stbtt__csctx_rccurve_to(c, s[i], s[i+1], s[i+2], s[i+3], s[i+4], s[i+5]);
- break;
-
- case 0x1A: // vvcurveto
- case 0x1B: // hhcurveto
- if (sp < 4) return STBTT__CSERR("(vv|hh)curveto stack");
- f = 0.0;
- if (sp & 1) { f = s[i]; i++; }
- for (; i + 3 < sp; i += 4) {
- if (b0 == 0x1B)
- stbtt__csctx_rccurve_to(c, s[i], f, s[i+1], s[i+2], s[i+3], 0.0);
- else
- stbtt__csctx_rccurve_to(c, f, s[i], s[i+1], s[i+2], 0.0, s[i+3]);
- f = 0.0;
- }
- break;
-
- case 0x0A: // callsubr
- if (!has_subrs) {
- if (info->fdselect.size)
- subrs = stbtt__cid_get_glyph_subrs(info, glyph_index);
- has_subrs = 1;
- }
- // FALLTHROUGH
- case 0x1D: // callgsubr
- if (sp < 1) return STBTT__CSERR("call(g|)subr stack");
- v = (int) s[--sp];
- if (subr_stack_height >= 10) return STBTT__CSERR("recursion limit");
- subr_stack[subr_stack_height++] = b;
- b = stbtt__get_subr(b0 == 0x0A ? subrs : info->gsubrs, v);
- if (b.size == 0) return STBTT__CSERR("subr not found");
- b.cursor = 0;
- clear_stack = 0;
- break;
-
- case 0x0B: // return
- if (subr_stack_height <= 0) return STBTT__CSERR("return outside subr");
- b = subr_stack[--subr_stack_height];
- clear_stack = 0;
- break;
-
- case 0x0E: // endchar
- stbtt__csctx_close_shape(c);
- return 1;
-
- case 0x0C: { // two-byte escape
- float dx1, dx2, dx3, dx4, dx5, dx6, dy1, dy2, dy3, dy4, dy5, dy6;
- float dx, dy;
- int b1 = stbtt__buf_get8(&b);
- switch (b1) {
- // @TODO These "flex" implementations ignore the flex-depth and resolution,
- // and always draw beziers.
- case 0x22: // hflex
- if (sp < 7) return STBTT__CSERR("hflex stack");
- dx1 = s[0];
- dx2 = s[1];
- dy2 = s[2];
- dx3 = s[3];
- dx4 = s[4];
- dx5 = s[5];
- dx6 = s[6];
- stbtt__csctx_rccurve_to(c, dx1, 0, dx2, dy2, dx3, 0);
- stbtt__csctx_rccurve_to(c, dx4, 0, dx5, -dy2, dx6, 0);
- break;
-
- case 0x23: // flex
- if (sp < 13) return STBTT__CSERR("flex stack");
- dx1 = s[0];
- dy1 = s[1];
- dx2 = s[2];
- dy2 = s[3];
- dx3 = s[4];
- dy3 = s[5];
- dx4 = s[6];
- dy4 = s[7];
- dx5 = s[8];
- dy5 = s[9];
- dx6 = s[10];
- dy6 = s[11];
- //fd is s[12]
- stbtt__csctx_rccurve_to(c, dx1, dy1, dx2, dy2, dx3, dy3);
- stbtt__csctx_rccurve_to(c, dx4, dy4, dx5, dy5, dx6, dy6);
- break;
-
- case 0x24: // hflex1
- if (sp < 9) return STBTT__CSERR("hflex1 stack");
- dx1 = s[0];
- dy1 = s[1];
- dx2 = s[2];
- dy2 = s[3];
- dx3 = s[4];
- dx4 = s[5];
- dx5 = s[6];
- dy5 = s[7];
- dx6 = s[8];
- stbtt__csctx_rccurve_to(c, dx1, dy1, dx2, dy2, dx3, 0);
- stbtt__csctx_rccurve_to(c, dx4, 0, dx5, dy5, dx6, -(dy1+dy2+dy5));
- break;
-
- case 0x25: // flex1
- if (sp < 11) return STBTT__CSERR("flex1 stack");
- dx1 = s[0];
- dy1 = s[1];
- dx2 = s[2];
- dy2 = s[3];
- dx3 = s[4];
- dy3 = s[5];
- dx4 = s[6];
- dy4 = s[7];
- dx5 = s[8];
- dy5 = s[9];
- dx6 = dy6 = s[10];
- dx = dx1+dx2+dx3+dx4+dx5;
- dy = dy1+dy2+dy3+dy4+dy5;
- if (STBTT_fabs(dx) > STBTT_fabs(dy))
- dy6 = -dy;
- else
- dx6 = -dx;
- stbtt__csctx_rccurve_to(c, dx1, dy1, dx2, dy2, dx3, dy3);
- stbtt__csctx_rccurve_to(c, dx4, dy4, dx5, dy5, dx6, dy6);
- break;
-
- default:
- return STBTT__CSERR("unimplemented");
- }
- } break;
-
- default:
- if (b0 != 255 && b0 != 28 && b0 < 32)
- return STBTT__CSERR("reserved operator");
-
- // push immediate
- if (b0 == 255) {
- f = (float)(stbtt_int32)stbtt__buf_get32(&b) / 0x10000;
- } else {
- stbtt__buf_skip(&b, -1);
- f = (float)(stbtt_int16)stbtt__cff_int(&b);
- }
- if (sp >= 48) return STBTT__CSERR("push stack overflow");
- s[sp++] = f;
- clear_stack = 0;
- break;
- }
- if (clear_stack) sp = 0;
- }
- return STBTT__CSERR("no endchar");
-
-#undef STBTT__CSERR
-}
-
-static int stbtt__GetGlyphShapeT2(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices)
-{
- // runs the charstring twice, once to count and once to output (to avoid realloc)
- stbtt__csctx count_ctx = STBTT__CSCTX_INIT(1);
- stbtt__csctx output_ctx = STBTT__CSCTX_INIT(0);
- if (stbtt__run_charstring(info, glyph_index, &count_ctx)) {
- *pvertices = (stbtt_vertex*)STBTT_malloc(count_ctx.num_vertices*sizeof(stbtt_vertex), info->userdata);
- output_ctx.pvertices = *pvertices;
- if (stbtt__run_charstring(info, glyph_index, &output_ctx)) {
- STBTT_assert(output_ctx.num_vertices == count_ctx.num_vertices);
- return output_ctx.num_vertices;
- }
- }
- *pvertices = NULL;
- return 0;
-}
-
-static int stbtt__GetGlyphInfoT2(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1)
-{
- stbtt__csctx c = STBTT__CSCTX_INIT(1);
- int r = stbtt__run_charstring(info, glyph_index, &c);
- if (x0) *x0 = r ? c.min_x : 0;
- if (y0) *y0 = r ? c.min_y : 0;
- if (x1) *x1 = r ? c.max_x : 0;
- if (y1) *y1 = r ? c.max_y : 0;
- return r ? c.num_vertices : 0;
-}
-
-STBTT_DEF int stbtt_GetGlyphShape(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices)
-{
- if (!info->cff.size)
- return stbtt__GetGlyphShapeTT(info, glyph_index, pvertices);
- else
- return stbtt__GetGlyphShapeT2(info, glyph_index, pvertices);
-}
-
-STBTT_DEF void stbtt_GetGlyphHMetrics(const stbtt_fontinfo *info, int glyph_index, int *advanceWidth, int *leftSideBearing)
-{
- stbtt_uint16 numOfLongHorMetrics = ttUSHORT(info->data+info->hhea + 34);
- if (glyph_index < numOfLongHorMetrics) {
- if (advanceWidth) *advanceWidth = ttSHORT(info->data + info->hmtx + 4*glyph_index);
- if (leftSideBearing) *leftSideBearing = ttSHORT(info->data + info->hmtx + 4*glyph_index + 2);
- } else {
- if (advanceWidth) *advanceWidth = ttSHORT(info->data + info->hmtx + 4*(numOfLongHorMetrics-1));
- if (leftSideBearing) *leftSideBearing = ttSHORT(info->data + info->hmtx + 4*numOfLongHorMetrics + 2*(glyph_index - numOfLongHorMetrics));
- }
-}
-
-STBTT_DEF int stbtt_GetKerningTableLength(const stbtt_fontinfo *info)
-{
- stbtt_uint8 *data = info->data + info->kern;
-
- // we only look at the first table. it must be 'horizontal' and format 0.
- if (!info->kern)
- return 0;
- if (ttUSHORT(data+2) < 1) // number of tables, need at least 1
- return 0;
- if (ttUSHORT(data+8) != 1) // horizontal flag must be set in format
- return 0;
-
- return ttUSHORT(data+10);
-}
-
-STBTT_DEF int stbtt_GetKerningTable(const stbtt_fontinfo *info, stbtt_kerningentry* table, int table_length)
-{
- stbtt_uint8 *data = info->data + info->kern;
- int k, length;
-
- // we only look at the first table. it must be 'horizontal' and format 0.
- if (!info->kern)
- return 0;
- if (ttUSHORT(data+2) < 1) // number of tables, need at least 1
- return 0;
- if (ttUSHORT(data+8) != 1) // horizontal flag must be set in format
- return 0;
-
- length = ttUSHORT(data+10);
- if (table_length < length)
- length = table_length;
-
- for (k = 0; k < length; k++)
- {
- table[k].glyph1 = ttUSHORT(data+18+(k*6));
- table[k].glyph2 = ttUSHORT(data+20+(k*6));
- table[k].advance = ttSHORT(data+22+(k*6));
- }
-
- return length;
-}
-
-static int stbtt__GetGlyphKernInfoAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2)
-{
- stbtt_uint8 *data = info->data + info->kern;
- stbtt_uint32 needle, straw;
- int l, r, m;
-
- // we only look at the first table. it must be 'horizontal' and format 0.
- if (!info->kern)
- return 0;
- if (ttUSHORT(data+2) < 1) // number of tables, need at least 1
- return 0;
- if (ttUSHORT(data+8) != 1) // horizontal flag must be set in format
- return 0;
-
- l = 0;
- r = ttUSHORT(data+10) - 1;
- needle = glyph1 << 16 | glyph2;
- while (l <= r) {
- m = (l + r) >> 1;
- straw = ttULONG(data+18+(m*6)); // note: unaligned read
- if (needle < straw)
- r = m - 1;
- else if (needle > straw)
- l = m + 1;
- else
- return ttSHORT(data+22+(m*6));
- }
- return 0;
-}
-
-static stbtt_int32 stbtt__GetCoverageIndex(stbtt_uint8 *coverageTable, int glyph)
-{
- stbtt_uint16 coverageFormat = ttUSHORT(coverageTable);
- switch (coverageFormat) {
- case 1: {
- stbtt_uint16 glyphCount = ttUSHORT(coverageTable + 2);
-
- // Binary search.
- stbtt_int32 l=0, r=glyphCount-1, m;
- int straw, needle=glyph;
- while (l <= r) {
- stbtt_uint8 *glyphArray = coverageTable + 4;
- stbtt_uint16 glyphID;
- m = (l + r) >> 1;
- glyphID = ttUSHORT(glyphArray + 2 * m);
- straw = glyphID;
- if (needle < straw)
- r = m - 1;
- else if (needle > straw)
- l = m + 1;
- else {
- return m;
- }
- }
- break;
- }
-
- case 2: {
- stbtt_uint16 rangeCount = ttUSHORT(coverageTable + 2);
- stbtt_uint8 *rangeArray = coverageTable + 4;
-
- // Binary search.
- stbtt_int32 l=0, r=rangeCount-1, m;
- int strawStart, strawEnd, needle=glyph;
- while (l <= r) {
- stbtt_uint8 *rangeRecord;
- m = (l + r) >> 1;
- rangeRecord = rangeArray + 6 * m;
- strawStart = ttUSHORT(rangeRecord);
- strawEnd = ttUSHORT(rangeRecord + 2);
- if (needle < strawStart)
- r = m - 1;
- else if (needle > strawEnd)
- l = m + 1;
- else {
- stbtt_uint16 startCoverageIndex = ttUSHORT(rangeRecord + 4);
- return startCoverageIndex + glyph - strawStart;
- }
- }
- break;
- }
-
- default: return -1; // unsupported
- }
-
- return -1;
-}
-
-static stbtt_int32 stbtt__GetGlyphClass(stbtt_uint8 *classDefTable, int glyph)
-{
- stbtt_uint16 classDefFormat = ttUSHORT(classDefTable);
- switch (classDefFormat)
- {
- case 1: {
- stbtt_uint16 startGlyphID = ttUSHORT(classDefTable + 2);
- stbtt_uint16 glyphCount = ttUSHORT(classDefTable + 4);
- stbtt_uint8 *classDef1ValueArray = classDefTable + 6;
-
- if (glyph >= startGlyphID && glyph < startGlyphID + glyphCount)
- return (stbtt_int32)ttUSHORT(classDef1ValueArray + 2 * (glyph - startGlyphID));
- break;
- }
-
- case 2: {
- stbtt_uint16 classRangeCount = ttUSHORT(classDefTable + 2);
- stbtt_uint8 *classRangeRecords = classDefTable + 4;
-
- // Binary search.
- stbtt_int32 l=0, r=classRangeCount-1, m;
- int strawStart, strawEnd, needle=glyph;
- while (l <= r) {
- stbtt_uint8 *classRangeRecord;
- m = (l + r) >> 1;
- classRangeRecord = classRangeRecords + 6 * m;
- strawStart = ttUSHORT(classRangeRecord);
- strawEnd = ttUSHORT(classRangeRecord + 2);
- if (needle < strawStart)
- r = m - 1;
- else if (needle > strawEnd)
- l = m + 1;
- else
- return (stbtt_int32)ttUSHORT(classRangeRecord + 4);
- }
- break;
- }
-
- default:
- return -1; // Unsupported definition type, return an error.
- }
-
- // "All glyphs not assigned to a class fall into class 0". (OpenType spec)
- return 0;
-}
-
-// Define to STBTT_assert(x) if you want to break on unimplemented formats.
-#define STBTT_GPOS_TODO_assert(x)
-
-static stbtt_int32 stbtt__GetGlyphGPOSInfoAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2)
-{
- stbtt_uint16 lookupListOffset;
- stbtt_uint8 *lookupList;
- stbtt_uint16 lookupCount;
- stbtt_uint8 *data;
- stbtt_int32 i, sti;
-
- if (!info->gpos) return 0;
-
- data = info->data + info->gpos;
-
- if (ttUSHORT(data+0) != 1) return 0; // Major version 1
- if (ttUSHORT(data+2) != 0) return 0; // Minor version 0
-
- lookupListOffset = ttUSHORT(data+8);
- lookupList = data + lookupListOffset;
- lookupCount = ttUSHORT(lookupList);
-
- for (i=0; i<lookupCount; ++i) {
- stbtt_uint16 lookupOffset = ttUSHORT(lookupList + 2 + 2 * i);
- stbtt_uint8 *lookupTable = lookupList + lookupOffset;
-
- stbtt_uint16 lookupType = ttUSHORT(lookupTable);
- stbtt_uint16 subTableCount = ttUSHORT(lookupTable + 4);
- stbtt_uint8 *subTableOffsets = lookupTable + 6;
- if (lookupType != 2) // Pair Adjustment Positioning Subtable
- continue;
-
- for (sti=0; sti<subTableCount; sti++) {
- stbtt_uint16 subtableOffset = ttUSHORT(subTableOffsets + 2 * sti);
- stbtt_uint8 *table = lookupTable + subtableOffset;
- stbtt_uint16 posFormat = ttUSHORT(table);
- stbtt_uint16 coverageOffset = ttUSHORT(table + 2);
- stbtt_int32 coverageIndex = stbtt__GetCoverageIndex(table + coverageOffset, glyph1);
- if (coverageIndex == -1) continue;
-
- switch (posFormat) {
- case 1: {
- stbtt_int32 l, r, m;
- int straw, needle;
- stbtt_uint16 valueFormat1 = ttUSHORT(table + 4);
- stbtt_uint16 valueFormat2 = ttUSHORT(table + 6);
- if (valueFormat1 == 4 && valueFormat2 == 0) { // Support more formats?
- stbtt_int32 valueRecordPairSizeInBytes = 2;
- stbtt_uint16 pairSetCount = ttUSHORT(table + 8);
- stbtt_uint16 pairPosOffset = ttUSHORT(table + 10 + 2 * coverageIndex);
- stbtt_uint8 *pairValueTable = table + pairPosOffset;
- stbtt_uint16 pairValueCount = ttUSHORT(pairValueTable);
- stbtt_uint8 *pairValueArray = pairValueTable + 2;
-
- if (coverageIndex >= pairSetCount) return 0;
-
- needle=glyph2;
- r=pairValueCount-1;
- l=0;
-
- // Binary search.
- while (l <= r) {
- stbtt_uint16 secondGlyph;
- stbtt_uint8 *pairValue;
- m = (l + r) >> 1;
- pairValue = pairValueArray + (2 + valueRecordPairSizeInBytes) * m;
- secondGlyph = ttUSHORT(pairValue);
- straw = secondGlyph;
- if (needle < straw)
- r = m - 1;
- else if (needle > straw)
- l = m + 1;
- else {
- stbtt_int16 xAdvance = ttSHORT(pairValue + 2);
- return xAdvance;
- }
- }
- } else
- return 0;
- break;
- }
-
- case 2: {
- stbtt_uint16 valueFormat1 = ttUSHORT(table + 4);
- stbtt_uint16 valueFormat2 = ttUSHORT(table + 6);
- if (valueFormat1 == 4 && valueFormat2 == 0) { // Support more formats?
- stbtt_uint16 classDef1Offset = ttUSHORT(table + 8);
- stbtt_uint16 classDef2Offset = ttUSHORT(table + 10);
- int glyph1class = stbtt__GetGlyphClass(table + classDef1Offset, glyph1);
- int glyph2class = stbtt__GetGlyphClass(table + classDef2Offset, glyph2);
-
- stbtt_uint16 class1Count = ttUSHORT(table + 12);
- stbtt_uint16 class2Count = ttUSHORT(table + 14);
- stbtt_uint8 *class1Records, *class2Records;
- stbtt_int16 xAdvance;
-
- if (glyph1class < 0 || glyph1class >= class1Count) return 0; // malformed
- if (glyph2class < 0 || glyph2class >= class2Count) return 0; // malformed
-
- class1Records = table + 16;
- class2Records = class1Records + 2 * (glyph1class * class2Count);
- xAdvance = ttSHORT(class2Records + 2 * glyph2class);
- return xAdvance;
- } else
- return 0;
- break;
- }
-
- default:
- return 0; // Unsupported position format
- }
- }
- }
-
- return 0;
-}
-
-STBTT_DEF int stbtt_GetGlyphKernAdvance(const stbtt_fontinfo *info, int g1, int g2)
-{
- int xAdvance = 0;
-
- if (info->gpos)
- xAdvance += stbtt__GetGlyphGPOSInfoAdvance(info, g1, g2);
- else if (info->kern)
- xAdvance += stbtt__GetGlyphKernInfoAdvance(info, g1, g2);
-
- return xAdvance;
-}
-
-STBTT_DEF int stbtt_GetCodepointKernAdvance(const stbtt_fontinfo *info, int ch1, int ch2)
-{
- if (!info->kern && !info->gpos) // if no kerning table, don't waste time looking up both codepoint->glyphs
- return 0;
- return stbtt_GetGlyphKernAdvance(info, stbtt_FindGlyphIndex(info,ch1), stbtt_FindGlyphIndex(info,ch2));
-}
-
-STBTT_DEF void stbtt_GetCodepointHMetrics(const stbtt_fontinfo *info, int codepoint, int *advanceWidth, int *leftSideBearing)
-{
- stbtt_GetGlyphHMetrics(info, stbtt_FindGlyphIndex(info,codepoint), advanceWidth, leftSideBearing);
-}
-
-STBTT_DEF void stbtt_GetFontVMetrics(const stbtt_fontinfo *info, int *ascent, int *descent, int *lineGap)
-{
- if (ascent ) *ascent = ttSHORT(info->data+info->hhea + 4);
- if (descent) *descent = ttSHORT(info->data+info->hhea + 6);
- if (lineGap) *lineGap = ttSHORT(info->data+info->hhea + 8);
-}
-
-STBTT_DEF int stbtt_GetFontVMetricsOS2(const stbtt_fontinfo *info, int *typoAscent, int *typoDescent, int *typoLineGap)
-{
- int tab = stbtt__find_table(info->data, info->fontstart, "OS/2");
- if (!tab)
- return 0;
- if (typoAscent ) *typoAscent = ttSHORT(info->data+tab + 68);
- if (typoDescent) *typoDescent = ttSHORT(info->data+tab + 70);
- if (typoLineGap) *typoLineGap = ttSHORT(info->data+tab + 72);
- return 1;
-}
-
-STBTT_DEF void stbtt_GetFontBoundingBox(const stbtt_fontinfo *info, int *x0, int *y0, int *x1, int *y1)
-{
- *x0 = ttSHORT(info->data + info->head + 36);
- *y0 = ttSHORT(info->data + info->head + 38);
- *x1 = ttSHORT(info->data + info->head + 40);
- *y1 = ttSHORT(info->data + info->head + 42);
-}
-
-STBTT_DEF float stbtt_ScaleForPixelHeight(const stbtt_fontinfo *info, float height)
-{
- int fheight = ttSHORT(info->data + info->hhea + 4) - ttSHORT(info->data + info->hhea + 6);
- return (float) height / fheight;
-}
-
-STBTT_DEF float stbtt_ScaleForMappingEmToPixels(const stbtt_fontinfo *info, float pixels)
-{
- int unitsPerEm = ttUSHORT(info->data + info->head + 18);
- return pixels / unitsPerEm;
-}
-
-STBTT_DEF void stbtt_FreeShape(const stbtt_fontinfo *info, stbtt_vertex *v)
-{
- STBTT_free(v, info->userdata);
-}
-
-STBTT_DEF stbtt_uint8 *stbtt_FindSVGDoc(const stbtt_fontinfo *info, int gl)
-{
- int i;
- stbtt_uint8 *data = info->data;
- stbtt_uint8 *svg_doc_list = data + stbtt__get_svg((stbtt_fontinfo *) info);
-
- int numEntries = ttUSHORT(svg_doc_list);
- stbtt_uint8 *svg_docs = svg_doc_list + 2;
-
- for(i=0; i<numEntries; i++) {
- stbtt_uint8 *svg_doc = svg_docs + (12 * i);
- if ((gl >= ttUSHORT(svg_doc)) && (gl <= ttUSHORT(svg_doc + 2)))
- return svg_doc;
- }
- return 0;
-}
-
-STBTT_DEF int stbtt_GetGlyphSVG(const stbtt_fontinfo *info, int gl, const char **svg)
-{
- stbtt_uint8 *data = info->data;
- stbtt_uint8 *svg_doc;
-
- if (info->svg == 0)
- return 0;
-
- svg_doc = stbtt_FindSVGDoc(info, gl);
- if (svg_doc != NULL) {
- *svg = (char *) data + info->svg + ttULONG(svg_doc + 4);
- return ttULONG(svg_doc + 8);
- } else {
- return 0;
- }
-}
-
-STBTT_DEF int stbtt_GetCodepointSVG(const stbtt_fontinfo *info, int unicode_codepoint, const char **svg)
-{
- return stbtt_GetGlyphSVG(info, stbtt_FindGlyphIndex(info, unicode_codepoint), svg);
-}
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// antialiasing software rasterizer
-//
-
-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)
-{
- int x0=0,y0=0,x1,y1; // =0 suppresses compiler warning
- if (!stbtt_GetGlyphBox(font, glyph, &x0,&y0,&x1,&y1)) {
- // e.g. space character
- if (ix0) *ix0 = 0;
- if (iy0) *iy0 = 0;
- if (ix1) *ix1 = 0;
- if (iy1) *iy1 = 0;
- } else {
- // move to integral bboxes (treating pixels as little squares, what pixels get touched)?
- if (ix0) *ix0 = STBTT_ifloor( x0 * scale_x + shift_x);
- if (iy0) *iy0 = STBTT_ifloor(-y1 * scale_y + shift_y);
- if (ix1) *ix1 = STBTT_iceil ( x1 * scale_x + shift_x);
- if (iy1) *iy1 = STBTT_iceil (-y0 * scale_y + shift_y);
- }
-}
-
-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)
-{
- stbtt_GetGlyphBitmapBoxSubpixel(font, glyph, scale_x, scale_y,0.0f,0.0f, ix0, iy0, ix1, iy1);
-}
-
-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)
-{
- stbtt_GetGlyphBitmapBoxSubpixel(font, stbtt_FindGlyphIndex(font,codepoint), scale_x, scale_y,shift_x,shift_y, ix0,iy0,ix1,iy1);
-}
-
-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)
-{
- stbtt_GetCodepointBitmapBoxSubpixel(font, codepoint, scale_x, scale_y,0.0f,0.0f, ix0,iy0,ix1,iy1);
-}
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// Rasterizer
-
-typedef struct stbtt__hheap_chunk
-{
- struct stbtt__hheap_chunk *next;
-} stbtt__hheap_chunk;
-
-typedef struct stbtt__hheap
-{
- struct stbtt__hheap_chunk *head;
- void *first_free;
- int num_remaining_in_head_chunk;
-} stbtt__hheap;
-
-static void *stbtt__hheap_alloc(stbtt__hheap *hh, size_t size, void *userdata)
-{
- if (hh->first_free) {
- void *p = hh->first_free;
- hh->first_free = * (void **) p;
- return p;
- } else {
- if (hh->num_remaining_in_head_chunk == 0) {
- int count = (size < 32 ? 2000 : size < 128 ? 800 : 100);
- stbtt__hheap_chunk *c = (stbtt__hheap_chunk *) STBTT_malloc(sizeof(stbtt__hheap_chunk) + size * count, userdata);
- if (c == NULL)
- return NULL;
- c->next = hh->head;
- hh->head = c;
- hh->num_remaining_in_head_chunk = count;
- }
- --hh->num_remaining_in_head_chunk;
- return (char *) (hh->head) + sizeof(stbtt__hheap_chunk) + size * hh->num_remaining_in_head_chunk;
- }
-}
-
-static void stbtt__hheap_free(stbtt__hheap *hh, void *p)
-{
- *(void **) p = hh->first_free;
- hh->first_free = p;
-}
-
-static void stbtt__hheap_cleanup(stbtt__hheap *hh, void *userdata)
-{
- stbtt__hheap_chunk *c = hh->head;
- while (c) {
- stbtt__hheap_chunk *n = c->next;
- STBTT_free(c, userdata);
- c = n;
- }
-}
-
-typedef struct stbtt__edge {
- float x0,y0, x1,y1;
- int invert;
-} stbtt__edge;
-
-
-typedef struct stbtt__active_edge
-{
- struct stbtt__active_edge *next;
- #if STBTT_RASTERIZER_VERSION==1
- int x,dx;
- float ey;
- int direction;
- #elif STBTT_RASTERIZER_VERSION==2
- float fx,fdx,fdy;
- float direction;
- float sy;
- float ey;
- #else
- #error "Unrecognized value of STBTT_RASTERIZER_VERSION"
- #endif
-} stbtt__active_edge;
-
-#if STBTT_RASTERIZER_VERSION == 1
-#define STBTT_FIXSHIFT 10
-#define STBTT_FIX (1 << STBTT_FIXSHIFT)
-#define STBTT_FIXMASK (STBTT_FIX-1)
-
-static stbtt__active_edge *stbtt__new_active(stbtt__hheap *hh, stbtt__edge *e, int off_x, float start_point, void *userdata)
-{
- stbtt__active_edge *z = (stbtt__active_edge *) stbtt__hheap_alloc(hh, sizeof(*z), userdata);
- float dxdy = (e->x1 - e->x0) / (e->y1 - e->y0);
- STBTT_assert(z != NULL);
- if (!z) return z;
-
- // round dx down to avoid overshooting
- if (dxdy < 0)
- z->dx = -STBTT_ifloor(STBTT_FIX * -dxdy);
- else
- z->dx = STBTT_ifloor(STBTT_FIX * dxdy);
-
- 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
- z->x -= off_x * STBTT_FIX;
-
- z->ey = e->y1;
- z->next = 0;
- z->direction = e->invert ? 1 : -1;
- return z;
-}
-#elif STBTT_RASTERIZER_VERSION == 2
-static stbtt__active_edge *stbtt__new_active(stbtt__hheap *hh, stbtt__edge *e, int off_x, float start_point, void *userdata)
-{
- stbtt__active_edge *z = (stbtt__active_edge *) stbtt__hheap_alloc(hh, sizeof(*z), userdata);
- float dxdy = (e->x1 - e->x0) / (e->y1 - e->y0);
- STBTT_assert(z != NULL);
- //STBTT_assert(e->y0 <= start_point);
- if (!z) return z;
- z->fdx = dxdy;
- z->fdy = dxdy != 0.0f ? (1.0f/dxdy) : 0.0f;
- z->fx = e->x0 + dxdy * (start_point - e->y0);
- z->fx -= off_x;
- z->direction = e->invert ? 1.0f : -1.0f;
- z->sy = e->y0;
- z->ey = e->y1;
- z->next = 0;
- return z;
-}
-#else
-#error "Unrecognized value of STBTT_RASTERIZER_VERSION"
-#endif
-
-#if STBTT_RASTERIZER_VERSION == 1
-// note: this routine clips fills that extend off the edges... ideally this
-// wouldn't happen, but it could happen if the truetype glyph bounding boxes
-// are wrong, or if the user supplies a too-small bitmap
-static void stbtt__fill_active_edges(unsigned char *scanline, int len, stbtt__active_edge *e, int max_weight)
-{
- // non-zero winding fill
- int x0=0, w=0;
-
- while (e) {
- if (w == 0) {
- // if we're currently at zero, we need to record the edge start point
- x0 = e->x; w += e->direction;
- } else {
- int x1 = e->x; w += e->direction;
- // if we went to zero, we need to draw
- if (w == 0) {
- int i = x0 >> STBTT_FIXSHIFT;
- int j = x1 >> STBTT_FIXSHIFT;
-
- if (i < len && j >= 0) {
- if (i == j) {
- // x0,x1 are the same pixel, so compute combined coverage
- scanline[i] = scanline[i] + (stbtt_uint8) ((x1 - x0) * max_weight >> STBTT_FIXSHIFT);
- } else {
- if (i >= 0) // add antialiasing for x0
- scanline[i] = scanline[i] + (stbtt_uint8) (((STBTT_FIX - (x0 & STBTT_FIXMASK)) * max_weight) >> STBTT_FIXSHIFT);
- else
- i = -1; // clip
-
- if (j < len) // add antialiasing for x1
- scanline[j] = scanline[j] + (stbtt_uint8) (((x1 & STBTT_FIXMASK) * max_weight) >> STBTT_FIXSHIFT);
- else
- j = len; // clip
-
- for (++i; i < j; ++i) // fill pixels between x0 and x1
- scanline[i] = scanline[i] + (stbtt_uint8) max_weight;
- }
- }
- }
- }
-
- e = e->next;
- }
-}
-
-static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e, int n, int vsubsample, int off_x, int off_y, void *userdata)
-{
- stbtt__hheap hh = { 0, 0, 0 };
- stbtt__active_edge *active = NULL;
- int y,j=0;
- int max_weight = (255 / vsubsample); // weight per vertical scanline
- int s; // vertical subsample index
- unsigned char scanline_data[512], *scanline;
-
- if (result->w > 512)
- scanline = (unsigned char *) STBTT_malloc(result->w, userdata);
- else
- scanline = scanline_data;
-
- y = off_y * vsubsample;
- e[n].y0 = (off_y + result->h) * (float) vsubsample + 1;
-
- while (j < result->h) {
- STBTT_memset(scanline, 0, result->w);
- for (s=0; s < vsubsample; ++s) {
- // find center of pixel for this scanline
- float scan_y = y + 0.5f;
- stbtt__active_edge **step = &active;
-
- // update all active edges;
- // remove all active edges that terminate before the center of this scanline
- while (*step) {
- stbtt__active_edge * z = *step;
- if (z->ey <= scan_y) {
- *step = z->next; // delete from list
- STBTT_assert(z->direction);
- z->direction = 0;
- stbtt__hheap_free(&hh, z);
- } else {
- z->x += z->dx; // advance to position for current scanline
- step = &((*step)->next); // advance through list
- }
- }
-
- // resort the list if needed
- for(;;) {
- int changed=0;
- step = &active;
- while (*step && (*step)->next) {
- if ((*step)->x > (*step)->next->x) {
- stbtt__active_edge *t = *step;
- stbtt__active_edge *q = t->next;
-
- t->next = q->next;
- q->next = t;
- *step = q;
- changed = 1;
- }
- step = &(*step)->next;
- }
- if (!changed) break;
- }
-
- // insert all edges that start before the center of this scanline -- omit ones that also end on this scanline
- while (e->y0 <= scan_y) {
- if (e->y1 > scan_y) {
- stbtt__active_edge *z = stbtt__new_active(&hh, e, off_x, scan_y, userdata);
- if (z != NULL) {
- // find insertion point
- if (active == NULL)
- active = z;
- else if (z->x < active->x) {
- // insert at front
- z->next = active;
- active = z;
- } else {
- // find thing to insert AFTER
- stbtt__active_edge *p = active;
- while (p->next && p->next->x < z->x)
- p = p->next;
- // at this point, p->next->x is NOT < z->x
- z->next = p->next;
- p->next = z;
- }
- }
- }
- ++e;
- }
-
- // now process all active edges in XOR fashion
- if (active)
- stbtt__fill_active_edges(scanline, result->w, active, max_weight);
-
- ++y;
- }
- STBTT_memcpy(result->pixels + j * result->stride, scanline, result->w);
- ++j;
- }
-
- stbtt__hheap_cleanup(&hh, userdata);
-
- if (scanline != scanline_data)
- STBTT_free(scanline, userdata);
-}
-
-#elif STBTT_RASTERIZER_VERSION == 2
-
-// the edge passed in here does not cross the vertical line at x or the vertical line at x+1
-// (i.e. it has already been clipped to those)
-static void stbtt__handle_clipped_edge(float *scanline, int x, stbtt__active_edge *e, float x0, float y0, float x1, float y1)
-{
- if (y0 == y1) return;
- STBTT_assert(y0 < y1);
- STBTT_assert(e->sy <= e->ey);
- if (y0 > e->ey) return;
- if (y1 < e->sy) return;
- if (y0 < e->sy) {
- x0 += (x1-x0) * (e->sy - y0) / (y1-y0);
- y0 = e->sy;
- }
- if (y1 > e->ey) {
- x1 += (x1-x0) * (e->ey - y1) / (y1-y0);
- y1 = e->ey;
- }
-
- if (x0 == x)
- STBTT_assert(x1 <= x+1);
- else if (x0 == x+1)
- STBTT_assert(x1 >= x);
- else if (x0 <= x)
- STBTT_assert(x1 <= x);
- else if (x0 >= x+1)
- STBTT_assert(x1 >= x+1);
- else
- STBTT_assert(x1 >= x && x1 <= x+1);
-
- if (x0 <= x && x1 <= x)
- scanline[x] += e->direction * (y1-y0);
- else if (x0 >= x+1 && x1 >= x+1)
- ;
- else {
- STBTT_assert(x0 >= x && x0 <= x+1 && x1 >= x && x1 <= x+1);
- scanline[x] += e->direction * (y1-y0) * (1-((x0-x)+(x1-x))/2); // coverage = 1 - average x position
- }
-}
-
-static float stbtt__sized_trapezoid_area(float height, float top_width, float bottom_width)
-{
- STBTT_assert(top_width >= 0);
- STBTT_assert(bottom_width >= 0);
- return (top_width + bottom_width) / 2.0f * height;
-}
-
-static float stbtt__position_trapezoid_area(float height, float tx0, float tx1, float bx0, float bx1)
-{
- return stbtt__sized_trapezoid_area(height, tx1 - tx0, bx1 - bx0);
-}
-
-static float stbtt__sized_triangle_area(float height, float width)
-{
- return height * width / 2;
-}
-
-static void stbtt__fill_active_edges_new(float *scanline, float *scanline_fill, int len, stbtt__active_edge *e, float y_top)
-{
- float y_bottom = y_top+1;
-
- while (e) {
- // brute force every pixel
-
- // compute intersection points with top & bottom
- STBTT_assert(e->ey >= y_top);
-
- if (e->fdx == 0) {
- float x0 = e->fx;
- if (x0 < len) {
- if (x0 >= 0) {
- stbtt__handle_clipped_edge(scanline,(int) x0,e, x0,y_top, x0,y_bottom);
- stbtt__handle_clipped_edge(scanline_fill-1,(int) x0+1,e, x0,y_top, x0,y_bottom);
- } else {
- stbtt__handle_clipped_edge(scanline_fill-1,0,e, x0,y_top, x0,y_bottom);
- }
- }
- } else {
- float x0 = e->fx;
- float dx = e->fdx;
- float xb = x0 + dx;
- float x_top, x_bottom;
- float sy0,sy1;
- float dy = e->fdy;
- STBTT_assert(e->sy <= y_bottom && e->ey >= y_top);
-
- // compute endpoints of line segment clipped to this scanline (if the
- // line segment starts on this scanline. x0 is the intersection of the
- // line with y_top, but that may be off the line segment.
- if (e->sy > y_top) {
- x_top = x0 + dx * (e->sy - y_top);
- sy0 = e->sy;
- } else {
- x_top = x0;
- sy0 = y_top;
- }
- if (e->ey < y_bottom) {
- x_bottom = x0 + dx * (e->ey - y_top);
- sy1 = e->ey;
- } else {
- x_bottom = xb;
- sy1 = y_bottom;
- }
-
- if (x_top >= 0 && x_bottom >= 0 && x_top < len && x_bottom < len) {
- // from here on, we don't have to range check x values
-
- if ((int) x_top == (int) x_bottom) {
- float height;
- // simple case, only spans one pixel
- int x = (int) x_top;
- height = (sy1 - sy0) * e->direction;
- STBTT_assert(x >= 0 && x < len);
- scanline[x] += stbtt__position_trapezoid_area(height, x_top, x+1.0f, x_bottom, x+1.0f);
- scanline_fill[x] += height; // everything right of this pixel is filled
- } else {
- int x,x1,x2;
- float y_crossing, y_final, step, sign, area;
- // covers 2+ pixels
- if (x_top > x_bottom) {
- // flip scanline vertically; signed area is the same
- float t;
- sy0 = y_bottom - (sy0 - y_top);
- sy1 = y_bottom - (sy1 - y_top);
- t = sy0, sy0 = sy1, sy1 = t;
- t = x_bottom, x_bottom = x_top, x_top = t;
- dx = -dx;
- dy = -dy;
- t = x0, x0 = xb, xb = t;
- }
- STBTT_assert(dy >= 0);
- STBTT_assert(dx >= 0);
-
- x1 = (int) x_top;
- x2 = (int) x_bottom;
- // compute intersection with y axis at x1+1
- y_crossing = y_top + dy * (x1+1 - x0);
-
- // compute intersection with y axis at x2
- y_final = y_top + dy * (x2 - x0);
-
- // x1 x_top x2 x_bottom
- // y_top +------|-----+------------+------------+--------|---+------------+
- // | | | | | |
- // | | | | | |
- // sy0 | Txxxxx|............|............|............|............|
- // y_crossing | *xxxxx.......|............|............|............|
- // | | xxxxx..|............|............|............|
- // | | /- xx*xxxx........|............|............|
- // | | dy < | xxxxxx..|............|............|
- // y_final | | \- | xx*xxx.........|............|
- // sy1 | | | | xxxxxB...|............|
- // | | | | | |
- // | | | | | |
- // y_bottom +------------+------------+------------+------------+------------+
- //
- // goal is to measure the area covered by '.' in each pixel
-
- // if x2 is right at the right edge of x1, y_crossing can blow up, github #1057
- // @TODO: maybe test against sy1 rather than y_bottom?
- if (y_crossing > y_bottom)
- y_crossing = y_bottom;
-
- sign = e->direction;
-
- // area of the rectangle covered from sy0..y_crossing
- area = sign * (y_crossing-sy0);
-
- // area of the triangle (x_top,sy0), (x1+1,sy0), (x1+1,y_crossing)
- scanline[x1] += stbtt__sized_triangle_area(area, x1+1 - x_top);
-
- // check if final y_crossing is blown up; no test case for this
- if (y_final > y_bottom) {
- y_final = y_bottom;
- dy = (y_final - y_crossing ) / (x2 - (x1+1)); // if denom=0, y_final = y_crossing, so y_final <= y_bottom
- }
-
- // in second pixel, area covered by line segment found in first pixel
- // is always a rectangle 1 wide * the height of that line segment; this
- // is exactly what the variable 'area' stores. it also gets a contribution
- // from the line segment within it. the THIRD pixel will get the first
- // pixel's rectangle contribution, the second pixel's rectangle contribution,
- // and its own contribution. the 'own contribution' is the same in every pixel except
- // the leftmost and rightmost, a trapezoid that slides down in each pixel.
- // the second pixel's contribution to the third pixel will be the
- // rectangle 1 wide times the height change in the second pixel, which is dy.
-
- step = sign * dy * 1; // dy is dy/dx, change in y for every 1 change in x,
- // which multiplied by 1-pixel-width is how much pixel area changes for each step in x
- // so the area advances by 'step' every time
-
- for (x = x1+1; x < x2; ++x) {
- scanline[x] += area + step/2; // area of trapezoid is 1*step/2
- area += step;
- }
- STBTT_assert(STBTT_fabs(area) <= 1.01f); // accumulated error from area += step unless we round step down
- STBTT_assert(sy1 > y_final-0.01f);
-
- // area covered in the last pixel is the rectangle from all the pixels to the left,
- // plus the trapezoid filled by the line segment in this pixel all the way to the right edge
- scanline[x2] += area + sign * stbtt__position_trapezoid_area(sy1-y_final, (float) x2, x2+1.0f, x_bottom, x2+1.0f);
-
- // the rest of the line is filled based on the total height of the line segment in this pixel
- scanline_fill[x2] += sign * (sy1-sy0);
- }
- } else {
- // if edge goes outside of box we're drawing, we require
- // clipping logic. since this does not match the intended use
- // of this library, we use a different, very slow brute
- // force implementation
- // note though that this does happen some of the time because
- // x_top and x_bottom can be extrapolated at the top & bottom of
- // the shape and actually lie outside the bounding box
- int x;
- for (x=0; x < len; ++x) {
- // cases:
- //
- // there can be up to two intersections with the pixel. any intersection
- // with left or right edges can be handled by splitting into two (or three)
- // regions. intersections with top & bottom do not necessitate case-wise logic.
- //
- // the old way of doing this found the intersections with the left & right edges,
- // then used some simple logic to produce up to three segments in sorted order
- // from top-to-bottom. however, this had a problem: if an x edge was epsilon
- // across the x border, then the corresponding y position might not be distinct
- // from the other y segment, and it might ignored as an empty segment. to avoid
- // that, we need to explicitly produce segments based on x positions.
-
- // rename variables to clearly-defined pairs
- float y0 = y_top;
- float x1 = (float) (x);
- float x2 = (float) (x+1);
- float x3 = xb;
- float y3 = y_bottom;
-
- // x = e->x + e->dx * (y-y_top)
- // (y-y_top) = (x - e->x) / e->dx
- // y = (x - e->x) / e->dx + y_top
- float y1 = (x - x0) / dx + y_top;
- float y2 = (x+1 - x0) / dx + y_top;
-
- if (x0 < x1 && x3 > x2) { // three segments descending down-right
- stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x1,y1);
- stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x2,y2);
- stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x3,y3);
- } else if (x3 < x1 && x0 > x2) { // three segments descending down-left
- stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x2,y2);
- stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x1,y1);
- stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x3,y3);
- } else if (x0 < x1 && x3 > x1) { // two segments across x, down-right
- stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x1,y1);
- stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x3,y3);
- } else if (x3 < x1 && x0 > x1) { // two segments across x, down-left
- stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x1,y1);
- stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x3,y3);
- } else if (x0 < x2 && x3 > x2) { // two segments across x+1, down-right
- stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x2,y2);
- stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x3,y3);
- } else if (x3 < x2 && x0 > x2) { // two segments across x+1, down-left
- stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x2,y2);
- stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x3,y3);
- } else { // one segment
- stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x3,y3);
- }
- }
- }
- }
- e = e->next;
- }
-}
-
-// directly AA rasterize edges w/o supersampling
-static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e, int n, int vsubsample, int off_x, int off_y, void *userdata)
-{
- stbtt__hheap hh = { 0, 0, 0 };
- stbtt__active_edge *active = NULL;
- int y,j=0, i;
- float scanline_data[129], *scanline, *scanline2;
-
- STBTT__NOTUSED(vsubsample);
-
- if (result->w > 64)
- scanline = (float *) STBTT_malloc((result->w*2+1) * sizeof(float), userdata);
- else
- scanline = scanline_data;
-
- scanline2 = scanline + result->w;
-
- y = off_y;
- e[n].y0 = (float) (off_y + result->h) + 1;
-
- while (j < result->h) {
- // find center of pixel for this scanline
- float scan_y_top = y + 0.0f;
- float scan_y_bottom = y + 1.0f;
- stbtt__active_edge **step = &active;
-
- STBTT_memset(scanline , 0, result->w*sizeof(scanline[0]));
- STBTT_memset(scanline2, 0, (result->w+1)*sizeof(scanline[0]));
-
- // update all active edges;
- // remove all active edges that terminate before the top of this scanline
- while (*step) {
- stbtt__active_edge * z = *step;
- if (z->ey <= scan_y_top) {
- *step = z->next; // delete from list
- STBTT_assert(z->direction);
- z->direction = 0;
- stbtt__hheap_free(&hh, z);
- } else {
- step = &((*step)->next); // advance through list
- }
- }
-
- // insert all edges that start before the bottom of this scanline
- while (e->y0 <= scan_y_bottom) {
- if (e->y0 != e->y1) {
- stbtt__active_edge *z = stbtt__new_active(&hh, e, off_x, scan_y_top, userdata);
- if (z != NULL) {
- if (j == 0 && off_y != 0) {
- if (z->ey < scan_y_top) {
- // this can happen due to subpixel positioning and some kind of fp rounding error i think
- z->ey = scan_y_top;
- }
- }
- STBTT_assert(z->ey >= scan_y_top); // if we get really unlucky a tiny bit of an edge can be out of bounds
- // insert at front
- z->next = active;
- active = z;
- }
- }
- ++e;
- }
-
- // now process all active edges
- if (active)
- stbtt__fill_active_edges_new(scanline, scanline2+1, result->w, active, scan_y_top);
-
- {
- float sum = 0;
- for (i=0; i < result->w; ++i) {
- float k;
- int m;
- sum += scanline2[i];
- k = scanline[i] + sum;
- k = (float) STBTT_fabs(k)*255 + 0.5f;
- m = (int) k;
- if (m > 255) m = 255;
- result->pixels[j*result->stride + i] = (unsigned char) m;
- }
- }
- // advance all the edges
- step = &active;
- while (*step) {
- stbtt__active_edge *z = *step;
- z->fx += z->fdx; // advance to position for current scanline
- step = &((*step)->next); // advance through list
- }
-
- ++y;
- ++j;
- }
-
- stbtt__hheap_cleanup(&hh, userdata);
-
- if (scanline != scanline_data)
- STBTT_free(scanline, userdata);
-}
-#else
-#error "Unrecognized value of STBTT_RASTERIZER_VERSION"
-#endif
-
-#define STBTT__COMPARE(a,b) ((a)->y0 < (b)->y0)
-
-static void stbtt__sort_edges_ins_sort(stbtt__edge *p, int n)
-{
- int i,j;
- for (i=1; i < n; ++i) {
- stbtt__edge t = p[i], *a = &t;
- j = i;
- while (j > 0) {
- stbtt__edge *b = &p[j-1];
- int c = STBTT__COMPARE(a,b);
- if (!c) break;
- p[j] = p[j-1];
- --j;
- }
- if (i != j)
- p[j] = t;
- }
-}
-
-static void stbtt__sort_edges_quicksort(stbtt__edge *p, int n)
-{
- /* threshold for transitioning to insertion sort */
- while (n > 12) {
- stbtt__edge t;
- int c01,c12,c,m,i,j;
-
- /* compute median of three */
- m = n >> 1;
- c01 = STBTT__COMPARE(&p[0],&p[m]);
- c12 = STBTT__COMPARE(&p[m],&p[n-1]);
- /* if 0 >= mid >= end, or 0 < mid < end, then use mid */
- if (c01 != c12) {
- /* otherwise, we'll need to swap something else to middle */
- int z;
- c = STBTT__COMPARE(&p[0],&p[n-1]);
- /* 0>mid && mid<n: 0>n => n; 0<n => 0 */
- /* 0<mid && mid>n: 0>n => 0; 0<n => n */
- z = (c == c12) ? 0 : n-1;
- t = p[z];
- p[z] = p[m];
- p[m] = t;
- }
- /* now p[m] is the median-of-three */
- /* swap it to the beginning so it won't move around */
- t = p[0];
- p[0] = p[m];
- p[m] = t;
-
- /* partition loop */
- i=1;
- j=n-1;
- for(;;) {
- /* handling of equality is crucial here */
- /* for sentinels & efficiency with duplicates */
- for (;;++i) {
- if (!STBTT__COMPARE(&p[i], &p[0])) break;
- }
- for (;;--j) {
- if (!STBTT__COMPARE(&p[0], &p[j])) break;
- }
- /* make sure we haven't crossed */
- if (i >= j) break;
- t = p[i];
- p[i] = p[j];
- p[j] = t;
-
- ++i;
- --j;
- }
- /* recurse on smaller side, iterate on larger */
- if (j < (n-i)) {
- stbtt__sort_edges_quicksort(p,j);
- p = p+i;
- n = n-i;
- } else {
- stbtt__sort_edges_quicksort(p+i, n-i);
- n = j;
- }
- }
-}
-
-static void stbtt__sort_edges(stbtt__edge *p, int n)
-{
- stbtt__sort_edges_quicksort(p, n);
- stbtt__sort_edges_ins_sort(p, n);
-}
-
-typedef struct
-{
- float x,y;
-} stbtt__point;
-
-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)
-{
- float y_scale_inv = invert ? -scale_y : scale_y;
- stbtt__edge *e;
- int n,i,j,k,m;
-#if STBTT_RASTERIZER_VERSION == 1
- int vsubsample = result->h < 8 ? 15 : 5;
-#elif STBTT_RASTERIZER_VERSION == 2
- int vsubsample = 1;
-#else
- #error "Unrecognized value of STBTT_RASTERIZER_VERSION"
-#endif
- // vsubsample should divide 255 evenly; otherwise we won't reach full opacity
-
- // now we have to blow out the windings into explicit edge lists
- n = 0;
- for (i=0; i < windings; ++i)
- n += wcount[i];
-
- e = (stbtt__edge *) STBTT_malloc(sizeof(*e) * (n+1), userdata); // add an extra one as a sentinel
- if (e == 0) return;
- n = 0;
-
- m=0;
- for (i=0; i < windings; ++i) {
- stbtt__point *p = pts + m;
- m += wcount[i];
- j = wcount[i]-1;
- for (k=0; k < wcount[i]; j=k++) {
- int a=k,b=j;
- // skip the edge if horizontal
- if (p[j].y == p[k].y)
- continue;
- // add edge from j to k to the list
- e[n].invert = 0;
- if (invert ? p[j].y > p[k].y : p[j].y < p[k].y) {
- e[n].invert = 1;
- a=j,b=k;
- }
- e[n].x0 = p[a].x * scale_x + shift_x;
- e[n].y0 = (p[a].y * y_scale_inv + shift_y) * vsubsample;
- e[n].x1 = p[b].x * scale_x + shift_x;
- e[n].y1 = (p[b].y * y_scale_inv + shift_y) * vsubsample;
- ++n;
- }
- }
-
- // now sort the edges by their highest point (should snap to integer, and then by x)
- //STBTT_sort(e, n, sizeof(e[0]), stbtt__edge_compare);
- stbtt__sort_edges(e, n);
-
- // now, traverse the scanlines and find the intersections on each scanline, use xor winding rule
- stbtt__rasterize_sorted_edges(result, e, n, vsubsample, off_x, off_y, userdata);
-
- STBTT_free(e, userdata);
-}
-
-static void stbtt__add_point(stbtt__point *points, int n, float x, float y)
-{
- if (!points) return; // during first pass, it's unallocated
- points[n].x = x;
- points[n].y = y;
-}
-
-// tessellate until threshold p is happy... @TODO warped to compensate for non-linear stretching
-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)
-{
- // midpoint
- float mx = (x0 + 2*x1 + x2)/4;
- float my = (y0 + 2*y1 + y2)/4;
- // versus directly drawn line
- float dx = (x0+x2)/2 - mx;
- float dy = (y0+y2)/2 - my;
- if (n > 16) // 65536 segments on one curve better be enough!
- return 1;
- if (dx*dx+dy*dy > objspace_flatness_squared) { // half-pixel error allowed... need to be smaller if AA
- stbtt__tesselate_curve(points, num_points, x0,y0, (x0+x1)/2.0f,(y0+y1)/2.0f, mx,my, objspace_flatness_squared,n+1);
- stbtt__tesselate_curve(points, num_points, mx,my, (x1+x2)/2.0f,(y1+y2)/2.0f, x2,y2, objspace_flatness_squared,n+1);
- } else {
- stbtt__add_point(points, *num_points,x2,y2);
- *num_points = *num_points+1;
- }
- return 1;
-}
-
-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)
-{
- // @TODO this "flatness" calculation is just made-up nonsense that seems to work well enough
- float dx0 = x1-x0;
- float dy0 = y1-y0;
- float dx1 = x2-x1;
- float dy1 = y2-y1;
- float dx2 = x3-x2;
- float dy2 = y3-y2;
- float dx = x3-x0;
- float dy = y3-y0;
- float longlen = (float) (STBTT_sqrt(dx0*dx0+dy0*dy0)+STBTT_sqrt(dx1*dx1+dy1*dy1)+STBTT_sqrt(dx2*dx2+dy2*dy2));
- float shortlen = (float) STBTT_sqrt(dx*dx+dy*dy);
- float flatness_squared = longlen*longlen-shortlen*shortlen;
-
- if (n > 16) // 65536 segments on one curve better be enough!
- return;
-
- if (flatness_squared > objspace_flatness_squared) {
- float x01 = (x0+x1)/2;
- float y01 = (y0+y1)/2;
- float x12 = (x1+x2)/2;
- float y12 = (y1+y2)/2;
- float x23 = (x2+x3)/2;
- float y23 = (y2+y3)/2;
-
- float xa = (x01+x12)/2;
- float ya = (y01+y12)/2;
- float xb = (x12+x23)/2;
- float yb = (y12+y23)/2;
-
- float mx = (xa+xb)/2;
- float my = (ya+yb)/2;
-
- stbtt__tesselate_cubic(points, num_points, x0,y0, x01,y01, xa,ya, mx,my, objspace_flatness_squared,n+1);
- stbtt__tesselate_cubic(points, num_points, mx,my, xb,yb, x23,y23, x3,y3, objspace_flatness_squared,n+1);
- } else {
- stbtt__add_point(points, *num_points,x3,y3);
- *num_points = *num_points+1;
- }
-}
-
-// returns number of contours
-static stbtt__point *stbtt_FlattenCurves(stbtt_vertex *vertices, int num_verts, float objspace_flatness, int **contour_lengths, int *num_contours, void *userdata)
-{
- stbtt__point *points=0;
- int num_points=0;
-
- float objspace_flatness_squared = objspace_flatness * objspace_flatness;
- int i,n=0,start=0, pass;
-
- // count how many "moves" there are to get the contour count
- for (i=0; i < num_verts; ++i)
- if (vertices[i].type == STBTT_vmove)
- ++n;
-
- *num_contours = n;
- if (n == 0) return 0;
-
- *contour_lengths = (int *) STBTT_malloc(sizeof(**contour_lengths) * n, userdata);
-
- if (*contour_lengths == 0) {
- *num_contours = 0;
- return 0;
- }
-
- // make two passes through the points so we don't need to realloc
- for (pass=0; pass < 2; ++pass) {
- float x=0,y=0;
- if (pass == 1) {
- points = (stbtt__point *) STBTT_malloc(num_points * sizeof(points[0]), userdata);
- if (points == NULL) goto error;
- }
- num_points = 0;
- n= -1;
- for (i=0; i < num_verts; ++i) {
- switch (vertices[i].type) {
- case STBTT_vmove:
- // start the next contour
- if (n >= 0)
- (*contour_lengths)[n] = num_points - start;
- ++n;
- start = num_points;
-
- x = vertices[i].x, y = vertices[i].y;
- stbtt__add_point(points, num_points++, x,y);
- break;
- case STBTT_vline:
- x = vertices[i].x, y = vertices[i].y;
- stbtt__add_point(points, num_points++, x, y);
- break;
- case STBTT_vcurve:
- stbtt__tesselate_curve(points, &num_points, x,y,
- vertices[i].cx, vertices[i].cy,
- vertices[i].x, vertices[i].y,
- objspace_flatness_squared, 0);
- x = vertices[i].x, y = vertices[i].y;
- break;
- case STBTT_vcubic:
- stbtt__tesselate_cubic(points, &num_points, x,y,
- vertices[i].cx, vertices[i].cy,
- vertices[i].cx1, vertices[i].cy1,
- vertices[i].x, vertices[i].y,
- objspace_flatness_squared, 0);
- x = vertices[i].x, y = vertices[i].y;
- break;
- }
- }
- (*contour_lengths)[n] = num_points - start;
- }
-
- return points;
-error:
- STBTT_free(points, userdata);
- STBTT_free(*contour_lengths, userdata);
- *contour_lengths = 0;
- *num_contours = 0;
- return NULL;
-}
-
-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)
-{
- float scale = scale_x > scale_y ? scale_y : scale_x;
- int winding_count = 0;
- int *winding_lengths = NULL;
- stbtt__point *windings = stbtt_FlattenCurves(vertices, num_verts, flatness_in_pixels / scale, &winding_lengths, &winding_count, userdata);
- if (windings) {
- stbtt__rasterize(result, windings, winding_lengths, winding_count, scale_x, scale_y, shift_x, shift_y, x_off, y_off, invert, userdata);
- STBTT_free(winding_lengths, userdata);
- STBTT_free(windings, userdata);
- }
-}
-
-STBTT_DEF void stbtt_FreeBitmap(unsigned char *bitmap, void *userdata)
-{
- STBTT_free(bitmap, userdata);
-}
-
-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)
-{
- int ix0,iy0,ix1,iy1;
- stbtt__bitmap gbm;
- stbtt_vertex *vertices;
- int num_verts = stbtt_GetGlyphShape(info, glyph, &vertices);
-
- if (scale_x == 0) scale_x = scale_y;
- if (scale_y == 0) {
- if (scale_x == 0) {
- STBTT_free(vertices, info->userdata);
- return NULL;
- }
- scale_y = scale_x;
- }
-
- stbtt_GetGlyphBitmapBoxSubpixel(info, glyph, scale_x, scale_y, shift_x, shift_y, &ix0,&iy0,&ix1,&iy1);
-
- // now we get the size
- gbm.w = (ix1 - ix0);
- gbm.h = (iy1 - iy0);
- gbm.pixels = NULL; // in case we error
-
- if (width ) *width = gbm.w;
- if (height) *height = gbm.h;
- if (xoff ) *xoff = ix0;
- if (yoff ) *yoff = iy0;
-
- if (gbm.w && gbm.h) {
- gbm.pixels = (unsigned char *) STBTT_malloc(gbm.w * gbm.h, info->userdata);
- if (gbm.pixels) {
- gbm.stride = gbm.w;
-
- stbtt_Rasterize(&gbm, 0.35f, vertices, num_verts, scale_x, scale_y, shift_x, shift_y, ix0, iy0, 1, info->userdata);
- }
- }
- STBTT_free(vertices, info->userdata);
- return gbm.pixels;
-}
-
-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)
-{
- return stbtt_GetGlyphBitmapSubpixel(info, scale_x, scale_y, 0.0f, 0.0f, glyph, width, height, xoff, yoff);
-}
-
-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)
-{
- int ix0,iy0;
- stbtt_vertex *vertices;
- int num_verts = stbtt_GetGlyphShape(info, glyph, &vertices);
- stbtt__bitmap gbm;
-
- stbtt_GetGlyphBitmapBoxSubpixel(info, glyph, scale_x, scale_y, shift_x, shift_y, &ix0,&iy0,0,0);
- gbm.pixels = output;
- gbm.w = out_w;
- gbm.h = out_h;
- gbm.stride = out_stride;
-
- if (gbm.w && gbm.h)
- stbtt_Rasterize(&gbm, 0.35f, vertices, num_verts, scale_x, scale_y, shift_x, shift_y, ix0,iy0, 1, info->userdata);
-
- STBTT_free(vertices, info->userdata);
-}
-
-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)
-{
- stbtt_MakeGlyphBitmapSubpixel(info, output, out_w, out_h, out_stride, scale_x, scale_y, 0.0f,0.0f, glyph);
-}
-
-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)
-{
- return stbtt_GetGlyphBitmapSubpixel(info, scale_x, scale_y,shift_x,shift_y, stbtt_FindGlyphIndex(info,codepoint), width,height,xoff,yoff);
-}
-
-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)
-{
- 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));
-}
-
-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)
-{
- stbtt_MakeGlyphBitmapSubpixel(info, output, out_w, out_h, out_stride, scale_x, scale_y, shift_x, shift_y, stbtt_FindGlyphIndex(info,codepoint));
-}
-
-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)
-{
- return stbtt_GetCodepointBitmapSubpixel(info, scale_x, scale_y, 0.0f,0.0f, codepoint, width,height,xoff,yoff);
-}
-
-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)
-{
- stbtt_MakeCodepointBitmapSubpixel(info, output, out_w, out_h, out_stride, scale_x, scale_y, 0.0f,0.0f, codepoint);
-}
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// bitmap baking
-//
-// This is SUPER-CRAPPY packing to keep source code small
-
-static int stbtt_BakeFontBitmap_internal(unsigned char *data, int offset, // font location (use offset=0 for plain .ttf)
- float pixel_height, // height of font in pixels
- unsigned char *pixels, int pw, int ph, // bitmap to be filled in
- int first_char, int num_chars, // characters to bake
- stbtt_bakedchar *chardata)
-{
- float scale;
- int x,y,bottom_y, i;
- stbtt_fontinfo f;
- f.userdata = NULL;
- if (!stbtt_InitFont(&f, data, offset))
- return -1;
- STBTT_memset(pixels, 0, pw*ph); // background of 0 around pixels
- x=y=1;
- bottom_y = 1;
-
- scale = stbtt_ScaleForPixelHeight(&f, pixel_height);
-
- for (i=0; i < num_chars; ++i) {
- int advance, lsb, x0,y0,x1,y1,gw,gh;
- int g = stbtt_FindGlyphIndex(&f, first_char + i);
- stbtt_GetGlyphHMetrics(&f, g, &advance, &lsb);
- stbtt_GetGlyphBitmapBox(&f, g, scale,scale, &x0,&y0,&x1,&y1);
- gw = x1-x0;
- gh = y1-y0;
- if (x + gw + 1 >= pw)
- y = bottom_y, x = 1; // advance to next row
- if (y + gh + 1 >= ph) // check if it fits vertically AFTER potentially moving to next row
- return -i;
- STBTT_assert(x+gw < pw);
- STBTT_assert(y+gh < ph);
- stbtt_MakeGlyphBitmap(&f, pixels+x+y*pw, gw,gh,pw, scale,scale, g);
- chardata[i].x0 = (stbtt_int16) x;
- chardata[i].y0 = (stbtt_int16) y;
- chardata[i].x1 = (stbtt_int16) (x + gw);
- chardata[i].y1 = (stbtt_int16) (y + gh);
- chardata[i].xadvance = scale * advance;
- chardata[i].xoff = (float) x0;
- chardata[i].yoff = (float) y0;
- x = x + gw + 1;
- if (y+gh+1 > bottom_y)
- bottom_y = y+gh+1;
- }
- return bottom_y;
-}
-
-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)
-{
- float d3d_bias = opengl_fillrule ? 0 : -0.5f;
- float ipw = 1.0f / pw, iph = 1.0f / ph;
- const stbtt_bakedchar *b = chardata + char_index;
- int round_x = STBTT_ifloor((*xpos + b->xoff) + 0.5f);
- int round_y = STBTT_ifloor((*ypos + b->yoff) + 0.5f);
-
- q->x0 = round_x + d3d_bias;
- q->y0 = round_y + d3d_bias;
- q->x1 = round_x + b->x1 - b->x0 + d3d_bias;
- q->y1 = round_y + b->y1 - b->y0 + d3d_bias;
-
- q->s0 = b->x0 * ipw;
- q->t0 = b->y0 * iph;
- q->s1 = b->x1 * ipw;
- q->t1 = b->y1 * iph;
-
- *xpos += b->xadvance;
-}
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// rectangle packing replacement routines if you don't have stb_rect_pack.h
-//
-
-#ifndef STB_RECT_PACK_VERSION
-
-typedef int stbrp_coord;
-
-////////////////////////////////////////////////////////////////////////////////////
-// //
-// //
-// COMPILER WARNING ?!?!? //
-// //
-// //
-// if you get a compile warning due to these symbols being defined more than //
-// once, move #include "stb_rect_pack.h" before #include "stb_truetype.h" //
-// //
-////////////////////////////////////////////////////////////////////////////////////
-
-typedef struct
-{
- int width,height;
- int x,y,bottom_y;
-} stbrp_context;
-
-typedef struct
-{
- unsigned char x;
-} stbrp_node;
-
-struct stbrp_rect
-{
- stbrp_coord x,y;
- int id,w,h,was_packed;
-};
-
-static void stbrp_init_target(stbrp_context *con, int pw, int ph, stbrp_node *nodes, int num_nodes)
-{
- con->width = pw;
- con->height = ph;
- con->x = 0;
- con->y = 0;
- con->bottom_y = 0;
- STBTT__NOTUSED(nodes);
- STBTT__NOTUSED(num_nodes);
-}
-
-static void stbrp_pack_rects(stbrp_context *con, stbrp_rect *rects, int num_rects)
-{
- int i;
- for (i=0; i < num_rects; ++i) {
- if (con->x + rects[i].w > con->width) {
- con->x = 0;
- con->y = con->bottom_y;
- }
- if (con->y + rects[i].h > con->height)
- break;
- rects[i].x = con->x;
- rects[i].y = con->y;
- rects[i].was_packed = 1;
- con->x += rects[i].w;
- if (con->y + rects[i].h > con->bottom_y)
- con->bottom_y = con->y + rects[i].h;
- }
- for ( ; i < num_rects; ++i)
- rects[i].was_packed = 0;
-}
-#endif
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// bitmap baking
-//
-// This is SUPER-AWESOME (tm Ryan Gordon) packing using stb_rect_pack.h. If
-// stb_rect_pack.h isn't available, it uses the BakeFontBitmap strategy.
-
-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)
-{
- stbrp_context *context = (stbrp_context *) STBTT_malloc(sizeof(*context) ,alloc_context);
- int num_nodes = pw - padding;
- stbrp_node *nodes = (stbrp_node *) STBTT_malloc(sizeof(*nodes ) * num_nodes,alloc_context);
-
- if (context == NULL || nodes == NULL) {
- if (context != NULL) STBTT_free(context, alloc_context);
- if (nodes != NULL) STBTT_free(nodes , alloc_context);
- return 0;
- }
-
- spc->user_allocator_context = alloc_context;
- spc->width = pw;
- spc->height = ph;
- spc->pixels = pixels;
- spc->pack_info = context;
- spc->nodes = nodes;
- spc->padding = padding;
- spc->stride_in_bytes = stride_in_bytes != 0 ? stride_in_bytes : pw;
- spc->h_oversample = 1;
- spc->v_oversample = 1;
- spc->skip_missing = 0;
-
- stbrp_init_target(context, pw-padding, ph-padding, nodes, num_nodes);
-
- if (pixels)
- STBTT_memset(pixels, 0, pw*ph); // background of 0 around pixels
-
- return 1;
-}
-
-STBTT_DEF void stbtt_PackEnd (stbtt_pack_context *spc)
-{
- STBTT_free(spc->nodes , spc->user_allocator_context);
- STBTT_free(spc->pack_info, spc->user_allocator_context);
-}
-
-STBTT_DEF void stbtt_PackSetOversampling(stbtt_pack_context *spc, unsigned int h_oversample, unsigned int v_oversample)
-{
- STBTT_assert(h_oversample <= STBTT_MAX_OVERSAMPLE);
- STBTT_assert(v_oversample <= STBTT_MAX_OVERSAMPLE);
- if (h_oversample <= STBTT_MAX_OVERSAMPLE)
- spc->h_oversample = h_oversample;
- if (v_oversample <= STBTT_MAX_OVERSAMPLE)
- spc->v_oversample = v_oversample;
-}
-
-STBTT_DEF void stbtt_PackSetSkipMissingCodepoints(stbtt_pack_context *spc, int skip)
-{
- spc->skip_missing = skip;
-}
-
-#define STBTT__OVER_MASK (STBTT_MAX_OVERSAMPLE-1)
-
-static void stbtt__h_prefilter(unsigned char *pixels, int w, int h, int stride_in_bytes, unsigned int kernel_width)
-{
- unsigned char buffer[STBTT_MAX_OVERSAMPLE];
- int safe_w = w - kernel_width;
- int j;
- STBTT_memset(buffer, 0, STBTT_MAX_OVERSAMPLE); // suppress bogus warning from VS2013 -analyze
- for (j=0; j < h; ++j) {
- int i;
- unsigned int total;
- STBTT_memset(buffer, 0, kernel_width);
-
- total = 0;
-
- // make kernel_width a constant in common cases so compiler can optimize out the divide
- switch (kernel_width) {
- case 2:
- for (i=0; i <= safe_w; ++i) {
- total += pixels[i] - buffer[i & STBTT__OVER_MASK];
- buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i];
- pixels[i] = (unsigned char) (total / 2);
- }
- break;
- case 3:
- for (i=0; i <= safe_w; ++i) {
- total += pixels[i] - buffer[i & STBTT__OVER_MASK];
- buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i];
- pixels[i] = (unsigned char) (total / 3);
- }
- break;
- case 4:
- for (i=0; i <= safe_w; ++i) {
- total += pixels[i] - buffer[i & STBTT__OVER_MASK];
- buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i];
- pixels[i] = (unsigned char) (total / 4);
- }
- break;
- case 5:
- for (i=0; i <= safe_w; ++i) {
- total += pixels[i] - buffer[i & STBTT__OVER_MASK];
- buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i];
- pixels[i] = (unsigned char) (total / 5);
- }
- break;
- default:
- for (i=0; i <= safe_w; ++i) {
- total += pixels[i] - buffer[i & STBTT__OVER_MASK];
- buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i];
- pixels[i] = (unsigned char) (total / kernel_width);
- }
- break;
- }
-
- for (; i < w; ++i) {
- STBTT_assert(pixels[i] == 0);
- total -= buffer[i & STBTT__OVER_MASK];
- pixels[i] = (unsigned char) (total / kernel_width);
- }
-
- pixels += stride_in_bytes;
- }
-}
-
-static void stbtt__v_prefilter(unsigned char *pixels, int w, int h, int stride_in_bytes, unsigned int kernel_width)
-{
- unsigned char buffer[STBTT_MAX_OVERSAMPLE];
- int safe_h = h - kernel_width;
- int j;
- STBTT_memset(buffer, 0, STBTT_MAX_OVERSAMPLE); // suppress bogus warning from VS2013 -analyze
- for (j=0; j < w; ++j) {
- int i;
- unsigned int total;
- STBTT_memset(buffer, 0, kernel_width);
-
- total = 0;
-
- // make kernel_width a constant in common cases so compiler can optimize out the divide
- switch (kernel_width) {
- case 2:
- for (i=0; i <= safe_h; ++i) {
- total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK];
- buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes];
- pixels[i*stride_in_bytes] = (unsigned char) (total / 2);
- }
- break;
- case 3:
- for (i=0; i <= safe_h; ++i) {
- total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK];
- buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes];
- pixels[i*stride_in_bytes] = (unsigned char) (total / 3);
- }
- break;
- case 4:
- for (i=0; i <= safe_h; ++i) {
- total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK];
- buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes];
- pixels[i*stride_in_bytes] = (unsigned char) (total / 4);
- }
- break;
- case 5:
- for (i=0; i <= safe_h; ++i) {
- total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK];
- buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes];
- pixels[i*stride_in_bytes] = (unsigned char) (total / 5);
- }
- break;
- default:
- for (i=0; i <= safe_h; ++i) {
- total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK];
- buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes];
- pixels[i*stride_in_bytes] = (unsigned char) (total / kernel_width);
- }
- break;
- }
-
- for (; i < h; ++i) {
- STBTT_assert(pixels[i*stride_in_bytes] == 0);
- total -= buffer[i & STBTT__OVER_MASK];
- pixels[i*stride_in_bytes] = (unsigned char) (total / kernel_width);
- }
-
- pixels += 1;
- }
-}
-
-static float stbtt__oversample_shift(int oversample)
-{
- if (!oversample)
- return 0.0f;
-
- // The prefilter is a box filter of width "oversample",
- // which shifts phase by (oversample - 1)/2 pixels in
- // oversampled space. We want to shift in the opposite
- // direction to counter this.
- return (float)-(oversample - 1) / (2.0f * (float)oversample);
-}
-
-// rects array must be big enough to accommodate all characters in the given ranges
-STBTT_DEF int stbtt_PackFontRangesGatherRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects)
-{
- int i,j,k;
- int missing_glyph_added = 0;
-
- k=0;
- for (i=0; i < num_ranges; ++i) {
- float fh = ranges[i].font_size;
- float scale = fh > 0 ? stbtt_ScaleForPixelHeight(info, fh) : stbtt_ScaleForMappingEmToPixels(info, -fh);
- ranges[i].h_oversample = (unsigned char) spc->h_oversample;
- ranges[i].v_oversample = (unsigned char) spc->v_oversample;
- for (j=0; j < ranges[i].num_chars; ++j) {
- int x0,y0,x1,y1;
- int codepoint = ranges[i].array_of_unicode_codepoints == NULL ? ranges[i].first_unicode_codepoint_in_range + j : ranges[i].array_of_unicode_codepoints[j];
- int glyph = stbtt_FindGlyphIndex(info, codepoint);
- if (glyph == 0 && (spc->skip_missing || missing_glyph_added)) {
- rects[k].w = rects[k].h = 0;
- } else {
- stbtt_GetGlyphBitmapBoxSubpixel(info,glyph,
- scale * spc->h_oversample,
- scale * spc->v_oversample,
- 0,0,
- &x0,&y0,&x1,&y1);
- rects[k].w = (stbrp_coord) (x1-x0 + spc->padding + spc->h_oversample-1);
- rects[k].h = (stbrp_coord) (y1-y0 + spc->padding + spc->v_oversample-1);
- if (glyph == 0)
- missing_glyph_added = 1;
- }
- ++k;
- }
- }
-
- return k;
-}
-
-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)
-{
- stbtt_MakeGlyphBitmapSubpixel(info,
- output,
- out_w - (prefilter_x - 1),
- out_h - (prefilter_y - 1),
- out_stride,
- scale_x,
- scale_y,
- shift_x,
- shift_y,
- glyph);
-
- if (prefilter_x > 1)
- stbtt__h_prefilter(output, out_w, out_h, out_stride, prefilter_x);
-
- if (prefilter_y > 1)
- stbtt__v_prefilter(output, out_w, out_h, out_stride, prefilter_y);
-
- *sub_x = stbtt__oversample_shift(prefilter_x);
- *sub_y = stbtt__oversample_shift(prefilter_y);
-}
-
-// rects array must be big enough to accommodate all characters in the given ranges
-STBTT_DEF int stbtt_PackFontRangesRenderIntoRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects)
-{
- int i,j,k, missing_glyph = -1, return_value = 1;
-
- // save current values
- int old_h_over = spc->h_oversample;
- int old_v_over = spc->v_oversample;
-
- k = 0;
- for (i=0; i < num_ranges; ++i) {
- float fh = ranges[i].font_size;
- float scale = fh > 0 ? stbtt_ScaleForPixelHeight(info, fh) : stbtt_ScaleForMappingEmToPixels(info, -fh);
- float recip_h,recip_v,sub_x,sub_y;
- spc->h_oversample = ranges[i].h_oversample;
- spc->v_oversample = ranges[i].v_oversample;
- recip_h = 1.0f / spc->h_oversample;
- recip_v = 1.0f / spc->v_oversample;
- sub_x = stbtt__oversample_shift(spc->h_oversample);
- sub_y = stbtt__oversample_shift(spc->v_oversample);
- for (j=0; j < ranges[i].num_chars; ++j) {
- stbrp_rect *r = &rects[k];
- if (r->was_packed && r->w != 0 && r->h != 0) {
- stbtt_packedchar *bc = &ranges[i].chardata_for_range[j];
- int advance, lsb, x0,y0,x1,y1;
- int codepoint = ranges[i].array_of_unicode_codepoints == NULL ? ranges[i].first_unicode_codepoint_in_range + j : ranges[i].array_of_unicode_codepoints[j];
- int glyph = stbtt_FindGlyphIndex(info, codepoint);
- stbrp_coord pad = (stbrp_coord) spc->padding;
-
- // pad on left and top
- r->x += pad;
- r->y += pad;
- r->w -= pad;
- r->h -= pad;
- stbtt_GetGlyphHMetrics(info, glyph, &advance, &lsb);
- stbtt_GetGlyphBitmapBox(info, glyph,
- scale * spc->h_oversample,
- scale * spc->v_oversample,
- &x0,&y0,&x1,&y1);
- stbtt_MakeGlyphBitmapSubpixel(info,
- spc->pixels + r->x + r->y*spc->stride_in_bytes,
- r->w - spc->h_oversample+1,
- r->h - spc->v_oversample+1,
- spc->stride_in_bytes,
- scale * spc->h_oversample,
- scale * spc->v_oversample,
- 0,0,
- glyph);
-
- if (spc->h_oversample > 1)
- stbtt__h_prefilter(spc->pixels + r->x + r->y*spc->stride_in_bytes,
- r->w, r->h, spc->stride_in_bytes,
- spc->h_oversample);
-
- if (spc->v_oversample > 1)
- stbtt__v_prefilter(spc->pixels + r->x + r->y*spc->stride_in_bytes,
- r->w, r->h, spc->stride_in_bytes,
- spc->v_oversample);
-
- bc->x0 = (stbtt_int16) r->x;
- bc->y0 = (stbtt_int16) r->y;
- bc->x1 = (stbtt_int16) (r->x + r->w);
- bc->y1 = (stbtt_int16) (r->y + r->h);
- bc->xadvance = scale * advance;
- bc->xoff = (float) x0 * recip_h + sub_x;
- bc->yoff = (float) y0 * recip_v + sub_y;
- bc->xoff2 = (x0 + r->w) * recip_h + sub_x;
- bc->yoff2 = (y0 + r->h) * recip_v + sub_y;
-
- if (glyph == 0)
- missing_glyph = j;
- } else if (spc->skip_missing) {
- return_value = 0;
- } else if (r->was_packed && r->w == 0 && r->h == 0 && missing_glyph >= 0) {
- ranges[i].chardata_for_range[j] = ranges[i].chardata_for_range[missing_glyph];
- } else {
- return_value = 0; // if any fail, report failure
- }
-
- ++k;
- }
- }
-
- // restore original values
- spc->h_oversample = old_h_over;
- spc->v_oversample = old_v_over;
-
- return return_value;
-}
-
-STBTT_DEF void stbtt_PackFontRangesPackRects(stbtt_pack_context *spc, stbrp_rect *rects, int num_rects)
-{
- stbrp_pack_rects((stbrp_context *) spc->pack_info, rects, num_rects);
-}
-
-STBTT_DEF int stbtt_PackFontRanges(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, stbtt_pack_range *ranges, int num_ranges)
-{
- stbtt_fontinfo info;
- int i,j,n, return_value = 1;
- //stbrp_context *context = (stbrp_context *) spc->pack_info;
- stbrp_rect *rects;
-
- // flag all characters as NOT packed
- for (i=0; i < num_ranges; ++i)
- for (j=0; j < ranges[i].num_chars; ++j)
- ranges[i].chardata_for_range[j].x0 =
- ranges[i].chardata_for_range[j].y0 =
- ranges[i].chardata_for_range[j].x1 =
- ranges[i].chardata_for_range[j].y1 = 0;
-
- n = 0;
- for (i=0; i < num_ranges; ++i)
- n += ranges[i].num_chars;
-
- rects = (stbrp_rect *) STBTT_malloc(sizeof(*rects) * n, spc->user_allocator_context);
- if (rects == NULL)
- return 0;
-
- info.userdata = spc->user_allocator_context;
- stbtt_InitFont(&info, fontdata, stbtt_GetFontOffsetForIndex(fontdata,font_index));
-
- n = stbtt_PackFontRangesGatherRects(spc, &info, ranges, num_ranges, rects);
-
- stbtt_PackFontRangesPackRects(spc, rects, n);
-
- return_value = stbtt_PackFontRangesRenderIntoRects(spc, &info, ranges, num_ranges, rects);
-
- STBTT_free(rects, spc->user_allocator_context);
- return return_value;
-}
-
-STBTT_DEF int stbtt_PackFontRange(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, float font_size,
- int first_unicode_codepoint_in_range, int num_chars_in_range, stbtt_packedchar *chardata_for_range)
-{
- stbtt_pack_range range;
- range.first_unicode_codepoint_in_range = first_unicode_codepoint_in_range;
- range.array_of_unicode_codepoints = NULL;
- range.num_chars = num_chars_in_range;
- range.chardata_for_range = chardata_for_range;
- range.font_size = font_size;
- return stbtt_PackFontRanges(spc, fontdata, font_index, &range, 1);
-}
-
-STBTT_DEF void stbtt_GetScaledFontVMetrics(const unsigned char *fontdata, int index, float size, float *ascent, float *descent, float *lineGap)
-{
- int i_ascent, i_descent, i_lineGap;
- float scale;
- stbtt_fontinfo info;
- stbtt_InitFont(&info, fontdata, stbtt_GetFontOffsetForIndex(fontdata, index));
- scale = size > 0 ? stbtt_ScaleForPixelHeight(&info, size) : stbtt_ScaleForMappingEmToPixels(&info, -size);
- stbtt_GetFontVMetrics(&info, &i_ascent, &i_descent, &i_lineGap);
- *ascent = (float) i_ascent * scale;
- *descent = (float) i_descent * scale;
- *lineGap = (float) i_lineGap * scale;
-}
-
-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)
-{
- float ipw = 1.0f / pw, iph = 1.0f / ph;
- const stbtt_packedchar *b = chardata + char_index;
-
- if (align_to_integer) {
- float x = (float) STBTT_ifloor((*xpos + b->xoff) + 0.5f);
- float y = (float) STBTT_ifloor((*ypos + b->yoff) + 0.5f);
- q->x0 = x;
- q->y0 = y;
- q->x1 = x + b->xoff2 - b->xoff;
- q->y1 = y + b->yoff2 - b->yoff;
- } else {
- q->x0 = *xpos + b->xoff;
- q->y0 = *ypos + b->yoff;
- q->x1 = *xpos + b->xoff2;
- q->y1 = *ypos + b->yoff2;
- }
-
- q->s0 = b->x0 * ipw;
- q->t0 = b->y0 * iph;
- q->s1 = b->x1 * ipw;
- q->t1 = b->y1 * iph;
-
- *xpos += b->xadvance;
-}
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// sdf computation
-//
-
-#define STBTT_min(a,b) ((a) < (b) ? (a) : (b))
-#define STBTT_max(a,b) ((a) < (b) ? (b) : (a))
-
-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])
-{
- float q0perp = q0[1]*ray[0] - q0[0]*ray[1];
- float q1perp = q1[1]*ray[0] - q1[0]*ray[1];
- float q2perp = q2[1]*ray[0] - q2[0]*ray[1];
- float roperp = orig[1]*ray[0] - orig[0]*ray[1];
-
- float a = q0perp - 2*q1perp + q2perp;
- float b = q1perp - q0perp;
- float c = q0perp - roperp;
-
- float s0 = 0., s1 = 0.;
- int num_s = 0;
-
- if (a != 0.0) {
- float discr = b*b - a*c;
- if (discr > 0.0) {
- float rcpna = -1 / a;
- float d = (float) STBTT_sqrt(discr);
- s0 = (b+d) * rcpna;
- s1 = (b-d) * rcpna;
- if (s0 >= 0.0 && s0 <= 1.0)
- num_s = 1;
- if (d > 0.0 && s1 >= 0.0 && s1 <= 1.0) {
- if (num_s == 0) s0 = s1;
- ++num_s;
- }
- }
- } else {
- // 2*b*s + c = 0
- // s = -c / (2*b)
- s0 = c / (-2 * b);
- if (s0 >= 0.0 && s0 <= 1.0)
- num_s = 1;
- }
-
- if (num_s == 0)
- return 0;
- else {
- float rcp_len2 = 1 / (ray[0]*ray[0] + ray[1]*ray[1]);
- float rayn_x = ray[0] * rcp_len2, rayn_y = ray[1] * rcp_len2;
-
- float q0d = q0[0]*rayn_x + q0[1]*rayn_y;
- float q1d = q1[0]*rayn_x + q1[1]*rayn_y;
- float q2d = q2[0]*rayn_x + q2[1]*rayn_y;
- float rod = orig[0]*rayn_x + orig[1]*rayn_y;
-
- float q10d = q1d - q0d;
- float q20d = q2d - q0d;
- float q0rd = q0d - rod;
-
- hits[0][0] = q0rd + s0*(2.0f - 2.0f*s0)*q10d + s0*s0*q20d;
- hits[0][1] = a*s0+b;
-
- if (num_s > 1) {
- hits[1][0] = q0rd + s1*(2.0f - 2.0f*s1)*q10d + s1*s1*q20d;
- hits[1][1] = a*s1+b;
- return 2;
- } else {
- return 1;
- }
- }
-}
-
-static int equal(float *a, float *b)
-{
- return (a[0] == b[0] && a[1] == b[1]);
-}
-
-static int stbtt__compute_crossings_x(float x, float y, int nverts, stbtt_vertex *verts)
-{
- int i;
- float orig[2], ray[2] = { 1, 0 };
- float y_frac;
- int winding = 0;
-
- // make sure y never passes through a vertex of the shape
- y_frac = (float) STBTT_fmod(y, 1.0f);
- if (y_frac < 0.01f)
- y += 0.01f;
- else if (y_frac > 0.99f)
- y -= 0.01f;
-
- orig[0] = x;
- orig[1] = y;
-
- // test a ray from (-infinity,y) to (x,y)
- for (i=0; i < nverts; ++i) {
- if (verts[i].type == STBTT_vline) {
- int x0 = (int) verts[i-1].x, y0 = (int) verts[i-1].y;
- int x1 = (int) verts[i ].x, y1 = (int) verts[i ].y;
- if (y > STBTT_min(y0,y1) && y < STBTT_max(y0,y1) && x > STBTT_min(x0,x1)) {
- float x_inter = (y - y0) / (y1 - y0) * (x1-x0) + x0;
- if (x_inter < x)
- winding += (y0 < y1) ? 1 : -1;
- }
- }
- if (verts[i].type == STBTT_vcurve) {
- int x0 = (int) verts[i-1].x , y0 = (int) verts[i-1].y ;
- int x1 = (int) verts[i ].cx, y1 = (int) verts[i ].cy;
- int x2 = (int) verts[i ].x , y2 = (int) verts[i ].y ;
- int ax = STBTT_min(x0,STBTT_min(x1,x2)), ay = STBTT_min(y0,STBTT_min(y1,y2));
- int by = STBTT_max(y0,STBTT_max(y1,y2));
- if (y > ay && y < by && x > ax) {
- float q0[2],q1[2],q2[2];
- float hits[2][2];
- q0[0] = (float)x0;
- q0[1] = (float)y0;
- q1[0] = (float)x1;
- q1[1] = (float)y1;
- q2[0] = (float)x2;
- q2[1] = (float)y2;
- if (equal(q0,q1) || equal(q1,q2)) {
- x0 = (int)verts[i-1].x;
- y0 = (int)verts[i-1].y;
- x1 = (int)verts[i ].x;
- y1 = (int)verts[i ].y;
- if (y > STBTT_min(y0,y1) && y < STBTT_max(y0,y1) && x > STBTT_min(x0,x1)) {
- float x_inter = (y - y0) / (y1 - y0) * (x1-x0) + x0;
- if (x_inter < x)
- winding += (y0 < y1) ? 1 : -1;
- }
- } else {
- int num_hits = stbtt__ray_intersect_bezier(orig, ray, q0, q1, q2, hits);
- if (num_hits >= 1)
- if (hits[0][0] < 0)
- winding += (hits[0][1] < 0 ? -1 : 1);
- if (num_hits >= 2)
- if (hits[1][0] < 0)
- winding += (hits[1][1] < 0 ? -1 : 1);
- }
- }
- }
- }
- return winding;
-}
-
-static float stbtt__cuberoot( float x )
-{
- if (x<0)
- return -(float) STBTT_pow(-x,1.0f/3.0f);
- else
- return (float) STBTT_pow( x,1.0f/3.0f);
-}
-
-// x^3 + a*x^2 + b*x + c = 0
-static int stbtt__solve_cubic(float a, float b, float c, float* r)
-{
- float s = -a / 3;
- float p = b - a*a / 3;
- float q = a * (2*a*a - 9*b) / 27 + c;
- float p3 = p*p*p;
- float d = q*q + 4*p3 / 27;
- if (d >= 0) {
- float z = (float) STBTT_sqrt(d);
- float u = (-q + z) / 2;
- float v = (-q - z) / 2;
- u = stbtt__cuberoot(u);
- v = stbtt__cuberoot(v);
- r[0] = s + u + v;
- return 1;
- } else {
- float u = (float) STBTT_sqrt(-p/3);
- float v = (float) STBTT_acos(-STBTT_sqrt(-27/p3) * q / 2) / 3; // p3 must be negative, since d is negative
- float m = (float) STBTT_cos(v);
- float n = (float) STBTT_cos(v-3.141592/2)*1.732050808f;
- r[0] = s + u * 2 * m;
- r[1] = s - u * (m + n);
- r[2] = s - u * (m - n);
-
- //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?
- //STBTT_assert( STBTT_fabs(((r[1]+a)*r[1]+b)*r[1]+c) < 0.05f);
- //STBTT_assert( STBTT_fabs(((r[2]+a)*r[2]+b)*r[2]+c) < 0.05f);
- return 3;
- }
-}
-
-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)
-{
- float scale_x = scale, scale_y = scale;
- int ix0,iy0,ix1,iy1;
- int w,h;
- unsigned char *data;
-
- if (scale == 0) return NULL;
-
- stbtt_GetGlyphBitmapBoxSubpixel(info, glyph, scale, scale, 0.0f,0.0f, &ix0,&iy0,&ix1,&iy1);
-
- // if empty, return NULL
- if (ix0 == ix1 || iy0 == iy1)
- return NULL;
-
- ix0 -= padding;
- iy0 -= padding;
- ix1 += padding;
- iy1 += padding;
-
- w = (ix1 - ix0);
- h = (iy1 - iy0);
-
- if (width ) *width = w;
- if (height) *height = h;
- if (xoff ) *xoff = ix0;
- if (yoff ) *yoff = iy0;
-
- // invert for y-downwards bitmaps
- scale_y = -scale_y;
-
- {
- int x,y,i,j;
- float *precompute;
- stbtt_vertex *verts;
- int num_verts = stbtt_GetGlyphShape(info, glyph, &verts);
- data = (unsigned char *) STBTT_malloc(w * h, info->userdata);
- precompute = (float *) STBTT_malloc(num_verts * sizeof(float), info->userdata);
-
- for (i=0,j=num_verts-1; i < num_verts; j=i++) {
- if (verts[i].type == STBTT_vline) {
- float x0 = verts[i].x*scale_x, y0 = verts[i].y*scale_y;
- float x1 = verts[j].x*scale_x, y1 = verts[j].y*scale_y;
- float dist = (float) STBTT_sqrt((x1-x0)*(x1-x0) + (y1-y0)*(y1-y0));
- precompute[i] = (dist == 0) ? 0.0f : 1.0f / dist;
- } else if (verts[i].type == STBTT_vcurve) {
- float x2 = verts[j].x *scale_x, y2 = verts[j].y *scale_y;
- float x1 = verts[i].cx*scale_x, y1 = verts[i].cy*scale_y;
- float x0 = verts[i].x *scale_x, y0 = verts[i].y *scale_y;
- float bx = x0 - 2*x1 + x2, by = y0 - 2*y1 + y2;
- float len2 = bx*bx + by*by;
- if (len2 != 0.0f)
- precompute[i] = 1.0f / (bx*bx + by*by);
- else
- precompute[i] = 0.0f;
- } else
- precompute[i] = 0.0f;
- }
-
- for (y=iy0; y < iy1; ++y) {
- for (x=ix0; x < ix1; ++x) {
- float val;
- float min_dist = 999999.0f;
- float sx = (float) x + 0.5f;
- float sy = (float) y + 0.5f;
- float x_gspace = (sx / scale_x);
- float y_gspace = (sy / scale_y);
-
- 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
-
- for (i=0; i < num_verts; ++i) {
- float x0 = verts[i].x*scale_x, y0 = verts[i].y*scale_y;
-
- if (verts[i].type == STBTT_vline && precompute[i] != 0.0f) {
- float x1 = verts[i-1].x*scale_x, y1 = verts[i-1].y*scale_y;
-
- float dist,dist2 = (x0-sx)*(x0-sx) + (y0-sy)*(y0-sy);
- if (dist2 < min_dist*min_dist)
- min_dist = (float) STBTT_sqrt(dist2);
-
- // coarse culling against bbox
- //if (sx > STBTT_min(x0,x1)-min_dist && sx < STBTT_max(x0,x1)+min_dist &&
- // sy > STBTT_min(y0,y1)-min_dist && sy < STBTT_max(y0,y1)+min_dist)
- dist = (float) STBTT_fabs((x1-x0)*(y0-sy) - (y1-y0)*(x0-sx)) * precompute[i];
- STBTT_assert(i != 0);
- if (dist < min_dist) {
- // check position along line
- // x' = x0 + t*(x1-x0), y' = y0 + t*(y1-y0)
- // minimize (x'-sx)*(x'-sx)+(y'-sy)*(y'-sy)
- float dx = x1-x0, dy = y1-y0;
- float px = x0-sx, py = y0-sy;
- // 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
- // derivative: 2*px*dx + 2*py*dy + (2*dx*dx+2*dy*dy)*t, set to 0 and solve
- float t = -(px*dx + py*dy) / (dx*dx + dy*dy);
- if (t >= 0.0f && t <= 1.0f)
- min_dist = dist;
- }
- } else if (verts[i].type == STBTT_vcurve) {
- float x2 = verts[i-1].x *scale_x, y2 = verts[i-1].y *scale_y;
- float x1 = verts[i ].cx*scale_x, y1 = verts[i ].cy*scale_y;
- float box_x0 = STBTT_min(STBTT_min(x0,x1),x2);
- float box_y0 = STBTT_min(STBTT_min(y0,y1),y2);
- float box_x1 = STBTT_max(STBTT_max(x0,x1),x2);
- float box_y1 = STBTT_max(STBTT_max(y0,y1),y2);
- // coarse culling against bbox to avoid computing cubic unnecessarily
- if (sx > box_x0-min_dist && sx < box_x1+min_dist && sy > box_y0-min_dist && sy < box_y1+min_dist) {
- int num=0;
- float ax = x1-x0, ay = y1-y0;
- float bx = x0 - 2*x1 + x2, by = y0 - 2*y1 + y2;
- float mx = x0 - sx, my = y0 - sy;
- float res[3] = {0.f,0.f,0.f};
- float px,py,t,it,dist2;
- float a_inv = precompute[i];
- if (a_inv == 0.0) { // if a_inv is 0, it's 2nd degree so use quadratic formula
- float a = 3*(ax*bx + ay*by);
- float b = 2*(ax*ax + ay*ay) + (mx*bx+my*by);
- float c = mx*ax+my*ay;
- if (a == 0.0) { // if a is 0, it's linear
- if (b != 0.0) {
- res[num++] = -c/b;
- }
- } else {
- float discriminant = b*b - 4*a*c;
- if (discriminant < 0)
- num = 0;
- else {
- float root = (float) STBTT_sqrt(discriminant);
- res[0] = (-b - root)/(2*a);
- res[1] = (-b + root)/(2*a);
- num = 2; // don't bother distinguishing 1-solution case, as code below will still work
- }
- }
- } else {
- float b = 3*(ax*bx + ay*by) * a_inv; // could precompute this as it doesn't depend on sample point
- float c = (2*(ax*ax + ay*ay) + (mx*bx+my*by)) * a_inv;
- float d = (mx*ax+my*ay) * a_inv;
- num = stbtt__solve_cubic(b, c, d, res);
- }
- dist2 = (x0-sx)*(x0-sx) + (y0-sy)*(y0-sy);
- if (dist2 < min_dist*min_dist)
- min_dist = (float) STBTT_sqrt(dist2);
-
- if (num >= 1 && res[0] >= 0.0f && res[0] <= 1.0f) {
- t = res[0], it = 1.0f - t;
- px = it*it*x0 + 2*t*it*x1 + t*t*x2;
- py = it*it*y0 + 2*t*it*y1 + t*t*y2;
- dist2 = (px-sx)*(px-sx) + (py-sy)*(py-sy);
- if (dist2 < min_dist * min_dist)
- min_dist = (float) STBTT_sqrt(dist2);
- }
- if (num >= 2 && res[1] >= 0.0f && res[1] <= 1.0f) {
- t = res[1], it = 1.0f - t;
- px = it*it*x0 + 2*t*it*x1 + t*t*x2;
- py = it*it*y0 + 2*t*it*y1 + t*t*y2;
- dist2 = (px-sx)*(px-sx) + (py-sy)*(py-sy);
- if (dist2 < min_dist * min_dist)
- min_dist = (float) STBTT_sqrt(dist2);
- }
- if (num >= 3 && res[2] >= 0.0f && res[2] <= 1.0f) {
- t = res[2], it = 1.0f - t;
- px = it*it*x0 + 2*t*it*x1 + t*t*x2;
- py = it*it*y0 + 2*t*it*y1 + t*t*y2;
- dist2 = (px-sx)*(px-sx) + (py-sy)*(py-sy);
- if (dist2 < min_dist * min_dist)
- min_dist = (float) STBTT_sqrt(dist2);
- }
- }
- }
- }
- if (winding == 0)
- min_dist = -min_dist; // if outside the shape, value is negative
- val = onedge_value + pixel_dist_scale * min_dist;
- if (val < 0)
- val = 0;
- else if (val > 255)
- val = 255;
- data[(y-iy0)*w+(x-ix0)] = (unsigned char) val;
- }
- }
- STBTT_free(precompute, info->userdata);
- STBTT_free(verts, info->userdata);
- }
- return data;
-}
-
-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)
-{
- return stbtt_GetGlyphSDF(info, scale, stbtt_FindGlyphIndex(info, codepoint), padding, onedge_value, pixel_dist_scale, width, height, xoff, yoff);
-}
-
-STBTT_DEF void stbtt_FreeSDF(unsigned char *bitmap, void *userdata)
-{
- STBTT_free(bitmap, userdata);
-}
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// font name matching -- recommended not to use this
-//
-
-// check if a utf8 string contains a prefix which is the utf16 string; if so return length of matching utf8 string
-static stbtt_int32 stbtt__CompareUTF8toUTF16_bigendian_prefix(stbtt_uint8 *s1, stbtt_int32 len1, stbtt_uint8 *s2, stbtt_int32 len2)
-{
- stbtt_int32 i=0;
-
- // convert utf16 to utf8 and compare the results while converting
- while (len2) {
- stbtt_uint16 ch = s2[0]*256 + s2[1];
- if (ch < 0x80) {
- if (i >= len1) return -1;
- if (s1[i++] != ch) return -1;
- } else if (ch < 0x800) {
- if (i+1 >= len1) return -1;
- if (s1[i++] != 0xc0 + (ch >> 6)) return -1;
- if (s1[i++] != 0x80 + (ch & 0x3f)) return -1;
- } else if (ch >= 0xd800 && ch < 0xdc00) {
- stbtt_uint32 c;
- stbtt_uint16 ch2 = s2[2]*256 + s2[3];
- if (i+3 >= len1) return -1;
- c = ((ch - 0xd800) << 10) + (ch2 - 0xdc00) + 0x10000;
- if (s1[i++] != 0xf0 + (c >> 18)) return -1;
- if (s1[i++] != 0x80 + ((c >> 12) & 0x3f)) return -1;
- if (s1[i++] != 0x80 + ((c >> 6) & 0x3f)) return -1;
- if (s1[i++] != 0x80 + ((c ) & 0x3f)) return -1;
- s2 += 2; // plus another 2 below
- len2 -= 2;
- } else if (ch >= 0xdc00 && ch < 0xe000) {
- return -1;
- } else {
- if (i+2 >= len1) return -1;
- if (s1[i++] != 0xe0 + (ch >> 12)) return -1;
- if (s1[i++] != 0x80 + ((ch >> 6) & 0x3f)) return -1;
- if (s1[i++] != 0x80 + ((ch ) & 0x3f)) return -1;
- }
- s2 += 2;
- len2 -= 2;
- }
- return i;
-}
-
-static int stbtt_CompareUTF8toUTF16_bigendian_internal(char *s1, int len1, char *s2, int len2)
-{
- return len1 == stbtt__CompareUTF8toUTF16_bigendian_prefix((stbtt_uint8*) s1, len1, (stbtt_uint8*) s2, len2);
-}
-
-// returns results in whatever encoding you request... but note that 2-byte encodings
-// will be BIG-ENDIAN... use stbtt_CompareUTF8toUTF16_bigendian() to compare
-STBTT_DEF const char *stbtt_GetFontNameString(const stbtt_fontinfo *font, int *length, int platformID, int encodingID, int languageID, int nameID)
-{
- stbtt_int32 i,count,stringOffset;
- stbtt_uint8 *fc = font->data;
- stbtt_uint32 offset = font->fontstart;
- stbtt_uint32 nm = stbtt__find_table(fc, offset, "name");
- if (!nm) return NULL;
-
- count = ttUSHORT(fc+nm+2);
- stringOffset = nm + ttUSHORT(fc+nm+4);
- for (i=0; i < count; ++i) {
- stbtt_uint32 loc = nm + 6 + 12 * i;
- if (platformID == ttUSHORT(fc+loc+0) && encodingID == ttUSHORT(fc+loc+2)
- && languageID == ttUSHORT(fc+loc+4) && nameID == ttUSHORT(fc+loc+6)) {
- *length = ttUSHORT(fc+loc+8);
- return (const char *) (fc+stringOffset+ttUSHORT(fc+loc+10));
- }
- }
- return NULL;
-}
-
-static int stbtt__matchpair(stbtt_uint8 *fc, stbtt_uint32 nm, stbtt_uint8 *name, stbtt_int32 nlen, stbtt_int32 target_id, stbtt_int32 next_id)
-{
- stbtt_int32 i;
- stbtt_int32 count = ttUSHORT(fc+nm+2);
- stbtt_int32 stringOffset = nm + ttUSHORT(fc+nm+4);
-
- for (i=0; i < count; ++i) {
- stbtt_uint32 loc = nm + 6 + 12 * i;
- stbtt_int32 id = ttUSHORT(fc+loc+6);
- if (id == target_id) {
- // find the encoding
- stbtt_int32 platform = ttUSHORT(fc+loc+0), encoding = ttUSHORT(fc+loc+2), language = ttUSHORT(fc+loc+4);
-
- // is this a Unicode encoding?
- if (platform == 0 || (platform == 3 && encoding == 1) || (platform == 3 && encoding == 10)) {
- stbtt_int32 slen = ttUSHORT(fc+loc+8);
- stbtt_int32 off = ttUSHORT(fc+loc+10);
-
- // check if there's a prefix match
- stbtt_int32 matchlen = stbtt__CompareUTF8toUTF16_bigendian_prefix(name, nlen, fc+stringOffset+off,slen);
- if (matchlen >= 0) {
- // check for target_id+1 immediately following, with same encoding & language
- 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) {
- slen = ttUSHORT(fc+loc+12+8);
- off = ttUSHORT(fc+loc+12+10);
- if (slen == 0) {
- if (matchlen == nlen)
- return 1;
- } else if (matchlen < nlen && name[matchlen] == ' ') {
- ++matchlen;
- if (stbtt_CompareUTF8toUTF16_bigendian_internal((char*) (name+matchlen), nlen-matchlen, (char*)(fc+stringOffset+off),slen))
- return 1;
- }
- } else {
- // if nothing immediately following
- if (matchlen == nlen)
- return 1;
- }
- }
- }
-
- // @TODO handle other encodings
- }
- }
- return 0;
-}
-
-static int stbtt__matches(stbtt_uint8 *fc, stbtt_uint32 offset, stbtt_uint8 *name, stbtt_int32 flags)
-{
- stbtt_int32 nlen = (stbtt_int32) STBTT_strlen((char *) name);
- stbtt_uint32 nm,hd;
- if (!stbtt__isfont(fc+offset)) return 0;
-
- // check italics/bold/underline flags in macStyle...
- if (flags) {
- hd = stbtt__find_table(fc, offset, "head");
- if ((ttUSHORT(fc+hd+44) & 7) != (flags & 7)) return 0;
- }
-
- nm = stbtt__find_table(fc, offset, "name");
- if (!nm) return 0;
-
- if (flags) {
- // if we checked the macStyle flags, then just check the family and ignore the subfamily
- if (stbtt__matchpair(fc, nm, name, nlen, 16, -1)) return 1;
- if (stbtt__matchpair(fc, nm, name, nlen, 1, -1)) return 1;
- if (stbtt__matchpair(fc, nm, name, nlen, 3, -1)) return 1;
- } else {
- if (stbtt__matchpair(fc, nm, name, nlen, 16, 17)) return 1;
- if (stbtt__matchpair(fc, nm, name, nlen, 1, 2)) return 1;
- if (stbtt__matchpair(fc, nm, name, nlen, 3, -1)) return 1;
- }
-
- return 0;
-}
-
-static int stbtt_FindMatchingFont_internal(unsigned char *font_collection, char *name_utf8, stbtt_int32 flags)
-{
- stbtt_int32 i;
- for (i=0;;++i) {
- stbtt_int32 off = stbtt_GetFontOffsetForIndex(font_collection, i);
- if (off < 0) return off;
- if (stbtt__matches((stbtt_uint8 *) font_collection, off, (stbtt_uint8*) name_utf8, flags))
- return off;
- }
-}
-
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wcast-qual"
-#endif
-
-STBTT_DEF int stbtt_BakeFontBitmap(const unsigned char *data, int offset,
- float pixel_height, unsigned char *pixels, int pw, int ph,
- int first_char, int num_chars, stbtt_bakedchar *chardata)
-{
- return stbtt_BakeFontBitmap_internal((unsigned char *) data, offset, pixel_height, pixels, pw, ph, first_char, num_chars, chardata);
-}
-
-STBTT_DEF int stbtt_GetFontOffsetForIndex(const unsigned char *data, int index)
-{
- return stbtt_GetFontOffsetForIndex_internal((unsigned char *) data, index);
-}
-
-STBTT_DEF int stbtt_GetNumberOfFonts(const unsigned char *data)
-{
- return stbtt_GetNumberOfFonts_internal((unsigned char *) data);
-}
-
-STBTT_DEF int stbtt_InitFont(stbtt_fontinfo *info, const unsigned char *data, int offset)
-{
- return stbtt_InitFont_internal(info, (unsigned char *) data, offset);
-}
-
-STBTT_DEF int stbtt_FindMatchingFont(const unsigned char *fontdata, const char *name, int flags)
-{
- return stbtt_FindMatchingFont_internal((unsigned char *) fontdata, (char *) name, flags);
-}
-
-STBTT_DEF int stbtt_CompareUTF8toUTF16_bigendian(const char *s1, int len1, const char *s2, int len2)
-{
- return stbtt_CompareUTF8toUTF16_bigendian_internal((char *) s1, len1, (char *) s2, len2);
-}
-
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-
-#endif // STB_TRUETYPE_IMPLEMENTATION
-
-
-// FULL VERSION HISTORY
-//
-// 1.25 (2021-07-11) many fixes
-// 1.24 (2020-02-05) fix warning
-// 1.23 (2020-02-02) query SVG data for glyphs; query whole kerning table (but only kern not GPOS)
-// 1.22 (2019-08-11) minimize missing-glyph duplication; fix kerning if both 'GPOS' and 'kern' are defined
-// 1.21 (2019-02-25) fix warning
-// 1.20 (2019-02-07) PackFontRange skips missing codepoints; GetScaleFontVMetrics()
-// 1.19 (2018-02-11) OpenType GPOS kerning (horizontal only), STBTT_fmod
-// 1.18 (2018-01-29) add missing function
-// 1.17 (2017-07-23) make more arguments const; doc fix
-// 1.16 (2017-07-12) SDF support
-// 1.15 (2017-03-03) make more arguments const
-// 1.14 (2017-01-16) num-fonts-in-TTC function
-// 1.13 (2017-01-02) support OpenType fonts, certain Apple fonts
-// 1.12 (2016-10-25) suppress warnings about casting away const with -Wcast-qual
-// 1.11 (2016-04-02) fix unused-variable warning
-// 1.10 (2016-04-02) allow user-defined fabs() replacement
-// fix memory leak if fontsize=0.0
-// fix warning from duplicate typedef
-// 1.09 (2016-01-16) warning fix; avoid crash on outofmem; use alloc userdata for PackFontRanges
-// 1.08 (2015-09-13) document stbtt_Rasterize(); fixes for vertical & horizontal edges
-// 1.07 (2015-08-01) allow PackFontRanges to accept arrays of sparse codepoints;
-// allow PackFontRanges to pack and render in separate phases;
-// fix stbtt_GetFontOFfsetForIndex (never worked for non-0 input?);
-// fixed an assert() bug in the new rasterizer
-// replace assert() with STBTT_assert() in new rasterizer
-// 1.06 (2015-07-14) performance improvements (~35% faster on x86 and x64 on test machine)
-// also more precise AA rasterizer, except if shapes overlap
-// remove need for STBTT_sort
-// 1.05 (2015-04-15) fix misplaced definitions for STBTT_STATIC
-// 1.04 (2015-04-15) typo in example
-// 1.03 (2015-04-12) STBTT_STATIC, fix memory leak in new packing, various fixes
-// 1.02 (2014-12-10) fix various warnings & compile issues w/ stb_rect_pack, C++
-// 1.01 (2014-12-08) fix subpixel position when oversampling to exactly match
-// non-oversampled; STBTT_POINT_SIZE for packed case only
-// 1.00 (2014-12-06) add new PackBegin etc. API, w/ support for oversampling
-// 0.99 (2014-09-18) fix multiple bugs with subpixel rendering (ryg)
-// 0.9 (2014-08-07) support certain mac/iOS fonts without an MS platformID
-// 0.8b (2014-07-07) fix a warning
-// 0.8 (2014-05-25) fix a few more warnings
-// 0.7 (2013-09-25) bugfix: subpixel glyph bug fixed in 0.5 had come back
-// 0.6c (2012-07-24) improve documentation
-// 0.6b (2012-07-20) fix a few more warnings
-// 0.6 (2012-07-17) fix warnings; added stbtt_ScaleForMappingEmToPixels,
-// stbtt_GetFontBoundingBox, stbtt_IsGlyphEmpty
-// 0.5 (2011-12-09) bugfixes:
-// subpixel glyph renderer computed wrong bounding box
-// first vertex of shape can be off-curve (FreeSans)
-// 0.4b (2011-12-03) fixed an error in the font baking example
-// 0.4 (2011-12-01) kerning, subpixel rendering (tor)
-// bugfixes for:
-// codepoint-to-glyph conversion using table fmt=12
-// codepoint-to-glyph conversion using table fmt=4
-// stbtt_GetBakedQuad with non-square texture (Zer)
-// updated Hello World! sample to use kerning and subpixel
-// fixed some warnings
-// 0.3 (2009-06-24) cmap fmt=12, compound shapes (MM)
-// userdata, malloc-from-userdata, non-zero fill (stb)
-// 0.2 (2009-03-11) Fix unsigned/signed char warnings
-// 0.1 (2009-03-09) First public release
-//
-
-/*
-------------------------------------------------------------------------------
-This software is available under 2 licenses -- choose whichever you prefer.
-------------------------------------------------------------------------------
-ALTERNATIVE A - MIT License
-Copyright (c) 2017 Sean Barrett
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-------------------------------------------------------------------------------
-ALTERNATIVE B - Public Domain (www.unlicense.org)
-This is free and unencumbered software released into the public domain.
-Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
-software, either in source code form or as a compiled binary, for any purpose,
-commercial or non-commercial, and by any means.
-In jurisdictions that recognize copyright laws, the author or authors of this
-software dedicate any and all copyright interest in the software to the public
-domain. We make this dedication for the benefit of the public at large and to
-the detriment of our heirs and successors. We intend this dedication to be an
-overt act of relinquishment in perpetuity of all present and future rights to
-this software under copyright law.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-------------------------------------------------------------------------------
-*/
diff --git a/std_printers.c b/std_printers.c
deleted file mode 100644
index abb111a..0000000
--- a/std_printers.c
+++ /dev/null
@@ -1,56 +0,0 @@
-#include <stdarg.h>
-#include <stdio.h>
-#include <unistd.h>
-
-extern int fileno(FILE*);
-
-void print(const char* fmt, ...) {
- va_list args;
- va_start(args, fmt);
- vfprintf(stdout, fmt, args);
- va_end(args);
-}
-
-void print_err(const char* fmt, ...) {
- va_list args;
- va_start(args, fmt);
-
- if (isatty(fileno(stderr))) {
- fprintf(stderr, "\033[31;31m");
- }
-
- vfprintf(stderr, fmt, args);
-
- if (isatty(fileno(stderr))) {
- fprintf(stderr, "\033[0m");
- }
-
- va_end(args);
-}
-
-void print_war(const char* fmt, ...) {
- va_list args;
- va_start(args, fmt);
-
- if (isatty(fileno(stderr))) {
- fprintf(stderr, "\033[31;35m");
- }
-
- vfprintf(stderr, fmt, args);
-
- if (isatty(fileno(stderr))) {
- fprintf(stderr, "\033[0m");
- }
-
- va_end(args);
-}
-
-void pbreak(Error code) {
-#if defined(DEBUG) && defined(plat_x86)
- __asm__("int3;");
- (void)code;
-#else
- exit(code);
-#endif
-}
-
diff --git a/ui.c b/ui.c
deleted file mode 100644
index a7d1070..0000000
--- a/ui.c
+++ /dev/null
@@ -1,152 +0,0 @@
-#include "config.h"
-#include "render.h"
-#include "plat.h"
-#include "rcache.h"
-#include "ui.h"
-
-Rectangle rectcut_left(Rectangle* l, int a) {
- Rectangle r;
- r.x = l->x;
- r.y = l->y;
- r.w = a;
- r.h = l->h;
- l->x += a;
- l->w -= a;
- return r;
-}
-
-Rectangle rectcut_right(Rectangle* l, int a) {
- Rectangle r;
- r.x = l->x + l->w - a;
- r.y = l->y;
- r.w = a;
- r.h = l->h;
- l->w -= a;
- return r;
-}
-
-Rectangle rectcut_top(Rectangle* l, int a) {
- Rectangle r;
- r.x = l->x;
- r.y = l->y;
- r.w = l->w;
- r.h = a;
- l->y += a;
- l->h -= a;
- return r;
-}
-
-Rectangle rectcut_bottom(Rectangle* l, int a) {
- Rectangle r;
- r.x = l->x;
- r.y = l->y + l->h - a;
- r.w = l->w;
- r.h = a;
- l->h -= a;
- return r;
-}
-
-Rectangle shrink_rect(const Rectangle* l, int a) {
- Rectangle r;
- int a2 = a * 2;
- r.x = l->x + a;
- r.y = l->y + a;
- r.w = l->w - a2;
- r.h = l->h - a2;
- return r;
-}
-
-Rectangle centre_rect(
- const Rectangle* l,
- const Rectangle* t
-) {
- Rectangle r;
- r.x = l->x + l->w / 2 - t->w / 2;
- r.y = l->y + l->h / 2 - t->h / 2;
- r.w = t->w;
- r.h = t->h;
- return r;
-}
-
-void init_ui(UI* u, Font* f) {
- u->font = f;
-}
-
-void ui_begin(UI* u, Rectangle* l) {
- (void)u;
- l->x = 0;
- l->y = 0;
- l->w = get_render_w();
- l->h = get_render_h();
-}
-
-void ui_end(UI* u) {
- (void)u;
-}
-
-void ui_label(
- UI* u,
- const Rectangle* l,
- const char* text
-) {
- rc_add_cmd_rfont_text_col(
- u->font,
- l->x,
- l->y,
- text,
- theme_text_colour
- );
-}
-
-int ui_button(
- UI* u,
- const Rectangle* r,
- const char* label
-) {
- Rectangle o, t;
- Colour c;
- int h;
- o = shrink_rect(r, theme_outline_width);
- h = point_rect_overlap(
- &o,
- get_mouse_x(),
- get_mouse_y()
- );
- if (h) {
- if (mbtn_pressed(mbtn_left))
- c = theme_active_colour;
- else
- c = theme_hovered_colour;
- } else
- c = theme_background_colour;
- rc_add_cmd_rect(r, theme_outline_colour);
- rc_add_cmd_rect(&o, c);
- t = text_rect(u->font, label);
- o = centre_rect(&o, &t);
- rc_add_cmd_rfont_text_col(
- u->font,
- o.x,
- o.y,
- label,
- theme_text_colour
- );
- return h && mbtn_just_released(mbtn_left);
-}
-
-void ui_container(
- UI* u,
- const Rectangle* l,
- Rectangle* r,
- const Rectangle* c
-) {
- Rectangle o, cl;
- (void)u;
- rc_add_cmd_rect(l, theme_outline_colour);
- o = shrink_rect(l, theme_outline_width);
- rc_add_cmd_rect(&o, theme_background_colour);
- cl = o;
- cl.w += cl.x;
- cl.h += cl.y;
- rc_add_cmd_clip(&cl);
- *r = shrink_rect(&o, theme_padding);
-}
diff --git a/ui.h b/ui.h
deleted file mode 100644
index 6a36566..0000000
--- a/ui.h
+++ /dev/null
@@ -1,41 +0,0 @@
-#ifndef ui_h
-#define ui_h
-
-#include "render.h"
-#include "rect.h"
-
-typedef struct {
- Font* font;
-} UI;
-
-Rectangle rectcut_left (Rectangle* l, int a);
-Rectangle rectcut_right (Rectangle* l, int a);
-Rectangle rectcut_top (Rectangle* l, int a);
-Rectangle rectcut_bottom(Rectangle* l, int a);
-Rectangle shrink_rect (const Rectangle* l, int a);
-Rectangle centre_rect (
- const Rectangle* l,
- const Rectangle* t
-);
-
-void init_ui(UI* u, Font* f);
-void ui_begin(UI* u, Rectangle* l);
-void ui_end(UI* u);
-int ui_button(
- UI* u,
- const Rectangle* l,
- const char* label
-);
-void ui_label(
- UI* u,
- const Rectangle* l,
- const char* text
-);
-void ui_container(
- UI* u,
- const Rectangle* l,
- Rectangle* r,
- const Rectangle* c
-);
-
-#endif