Merge pull request #96 from YosysHQ/imgui

Imgui integration

8 files changed, 670 insertions, 0 deletions

diff --git a/3rdparty/imgui/misc/fonts/Cousine-Regular.ttf b/3rdparty/imgui/misc/fonts/Cousine-Regular.ttf
new file mode 100644
index 00000000..70a0bf90
--- /dev/null
+++ b/3rdparty/imgui/misc/fonts/Cousine-Regular.ttf
diff --git a/3rdparty/imgui/misc/fonts/DroidSans.ttf b/3rdparty/imgui/misc/fonts/DroidSans.ttf
new file mode 100644
index 00000000..767c63ad
--- /dev/null
+++ b/3rdparty/imgui/misc/fonts/DroidSans.ttf
diff --git a/3rdparty/imgui/misc/fonts/Karla-Regular.ttf b/3rdparty/imgui/misc/fonts/Karla-Regular.ttf
new file mode 100644
index 00000000..81b3de6e
--- /dev/null
+++ b/3rdparty/imgui/misc/fonts/Karla-Regular.ttf
diff --git a/3rdparty/imgui/misc/fonts/ProggyClean.ttf b/3rdparty/imgui/misc/fonts/ProggyClean.ttf
new file mode 100644
index 00000000..0270cdfe
--- /dev/null
+++ b/3rdparty/imgui/misc/fonts/ProggyClean.ttf
diff --git a/3rdparty/imgui/misc/fonts/ProggyTiny.ttf b/3rdparty/imgui/misc/fonts/ProggyTiny.ttf
new file mode 100644
index 00000000..1c4312c3
--- /dev/null
+++ b/3rdparty/imgui/misc/fonts/ProggyTiny.ttf
diff --git a/3rdparty/imgui/misc/fonts/README.txt b/3rdparty/imgui/misc/fonts/README.txt
new file mode 100644
index 00000000..a40bb3d1
--- /dev/null
+++ b/3rdparty/imgui/misc/fonts/README.txt
@@ -0,0 +1,290 @@
+
+The code in imgui.cpp embeds a copy of 'ProggyClean.ttf' (by Tristan Grimmer),
+a 13 pixels high, pixel-perfect font used by default.
+We embed it font in source code so you can use Dear ImGui without any file system access.
+
+You may also load external .TTF/.OTF files. 
+The files in this folder are suggested fonts, provided as a convenience.
+(Note: .OTF support in imstb_truetype.h currently doesn't appear to load every font)
+
+Fonts are rasterized in a single texture at the time of calling either of io.Fonts->GetTexDataAsAlpha8()/GetTexDataAsRGBA32()/Build().
+Also read dear imgui FAQ in imgui.cpp!
+
+If you have other loading/merging/adding fonts, you can post on the Dear ImGui "Getting Started" forum:
+  https://discourse.dearimgui.org/c/getting-started
+
+
+---------------------------------------
+ INDEX:
+---------------------------------------
+
+- Readme First / FAQ
+- Using Icons
+- Fonts Loading Instructions
+- FreeType rasterizer, Small font sizes
+- Building Custom Glyph Ranges
+- Embedding Fonts in Source Code
+- Credits/Licences for fonts included in this folder
+- Links, Other fonts
+
+
+---------------------------------------
+ README FIRST / FAQ
+---------------------------------------
+
+ - You can use the style editor ImGui::ShowStyleEditor() to browse your fonts and understand what's going on if you have an issue.
+ - Make sure your font ranges data are persistent (available during the call to GetTexDataAsAlpha8()/GetTexDataAsRGBA32()/Build().
+ - Use C++11 u8"my text" syntax to encode literal strings as UTF-8. e.g.:
+       u8"hello"
+       u8"こんにちは"   // this will be encoded as UTF-8
+ - If you want to include a backslash \ character in your string literal, you need to double them e.g. "folder\\filename".
+ - Please use the Discourse forum (https://discourse.dearimgui.org) and not the Github issue tracker for basic font loading questions.
+
+
+---------------------------------------
+ USING ICONS
+---------------------------------------
+
+ Using an icon font (such as FontAwesome: http://fontawesome.io) is an easy and practical way to use icons in your ImGui application.
+ A common pattern is to merge the icon font within your main font, so you can embed icons directly from your strings without 
+ having to change fonts back and forth.
+
+ To refer to the icon UTF-8 codepoints from your C++ code, you may use those headers files created by Juliette Foucaut:
+   https://github.com/juliettef/IconFontCppHeaders
+
+ The C++11 version of those files uses the u8"" utf-8 encoding syntax + \u
+   #define ICON_FA_SEARCH  u8"\uf002"
+ The pre-C++11 version has the values directly encoded as utf-8:
+   #define ICON_FA_SEARCH  "\xEF\x80\x82"
+
+ Example:
+
+    // Merge icons into default tool font
+   #include "IconsFontAwesome.h"
+   ImGuiIO& io = ImGui::GetIO();
+   io.Fonts->AddFontDefault();
+
+   ImFontConfig config;
+   config.MergeMode = true;
+   config.GlyphMinAdvanceX = 13.0f; // Use if you want to make the icon monospaced
+   static const ImWchar icon_ranges[] = { ICON_MIN_FA, ICON_MAX_FA, 0 };
+   io.Fonts->AddFontFromFileTTF("fonts/fontawesome-webfont.ttf", 13.0f, &config, icon_ranges);
+
+   // Usage, e.g.
+   ImGui::Button(ICON_FA_SEARCH " Search");
+   // C string _literals_ can be concatenated at compilation time, e.g. "hello" " world"
+   // ICON_FA_SEARCH is defined as a string literal so this is the same as "A" "B" becoming "AB" 
+
+   // Usage, e.g.
+   ImGui::Text("%s among %d items", ICON_FA_SEARCH, count);
+   
+ See Links below for other icons fonts and related tools.
+
+
+---------------------------------------
+ FONTS LOADING INSTRUCTIONS
+---------------------------------------
+
+ Load default font:
+
+   ImGuiIO& io = ImGui::GetIO();
+   io.Fonts->AddFontDefault();
+
+ Load .TTF/.OTF file with:
+
+   ImGuiIO& io = ImGui::GetIO();
+   ImFont* font1 = io.Fonts->AddFontFromFileTTF("font.ttf", size_pixels);
+   ImFont* font2 = io.Fonts->AddFontFromFileTTF("anotherfont.otf", size_pixels);
+  
+   // Select font at runtime
+   ImGui::Text("Hello");	// use the default font (which is the first loaded font)
+   ImGui::PushFont(font2);
+   ImGui::Text("Hello with another font");
+   ImGui::PopFont();
+
+ For advanced options create a ImFontConfig structure and pass it to the AddFont function (it will be copied internally):
+
+   ImFontConfig config;
+   config.OversampleH = 3;
+   config.OversampleV = 1;
+   config.GlyphExtraSpacing.x = 1.0f;
+   ImFont* font = io.Fonts->AddFontFromFileTTF("font.ttf", size_pixels, &config);
+
+ If you have very large number of glyphs or multiple fonts, the texture may become too big for your graphics API.
+ The typical result of failing to upload a texture is if every glyphs appears as white rectangles.
+ In particular, using a large range such as GetGlyphRangesChineseSimplifiedCommon() is not recommended unless you 
+ set OversampleH/OversampleV to 1 and use a small font size.
+ Mind the fact that some graphics drivers have texture size limitation.
+ If you are building a PC application, mind the fact that your users may use hardware with lower limitations than yours.
+ Some solutions:
+
+  - 1) Reduce glyphs ranges by calculating them from source localization data. You can use ImFont::GlyphRangesBuilder for this purpose,
+    this will be the biggest win. 
+  - 2) You may reduce oversampling, e.g. config.OversampleH = config.OversampleV = 1, this will largely reduce your texture size.
+  - 3) Set io.Fonts.TexDesiredWidth to specify a texture width to minimize texture height (see comment in ImFontAtlas::Build function).
+  - 4) Set io.Fonts.Flags |= ImFontAtlasFlags_NoPowerOfTwoHeight; to disable rounding the texture height to the next power of two.
+
+ Combine two fonts into one:
+
+   // Load a first font
+   ImFont* font = io.Fonts->AddFontDefault();
+
+   // Add character ranges and merge into the previous font
+   // The ranges array is not copied by the AddFont* functions and is used lazily
+   // so ensure it is available at the time of building or calling GetTexDataAsRGBA32().
+   static const ImWchar icons_ranges[] = { 0xf000, 0xf3ff, 0 }; // Will not be copied by AddFont* so keep in scope.
+   ImFontConfig config;
+   config.MergeMode = true;
+   io.Fonts->AddFontFromFileTTF("DroidSans.ttf", 18.0f, &config, io.Fonts->GetGlyphRangesJapanese());
+   io.Fonts->AddFontFromFileTTF("fontawesome-webfont.ttf", 18.0f, &config, icons_ranges);
+   io.Fonts->Build();
+
+ Add a fourth parameter to bake specific font ranges only:
+
+   // Basic Latin, Extended Latin
+   io.Fonts->AddFontFromFileTTF("font.ttf", size_pixels, NULL, io.Fonts->GetGlyphRangesDefault());
+   
+   // Default + Selection of 2500 Ideographs used by Simplified Chinese
+   io.Fonts->AddFontFromFileTTF("font.ttf", size_pixels, NULL, io.Fonts->GetGlyphRangesChineseSimplifiedCommon());
+   
+   // Default + Hiragana, Katakana, Half-Width, Selection of 1946 Ideographs
+   io.Fonts->AddFontFromFileTTF("font.ttf", size_pixels, NULL, io.Fonts->GetGlyphRangesJapanese());
+
+ See "BUILDING CUSTOM GLYPH RANGES" section to create your own ranges. 
+ Offset font vertically by altering the io.Font->DisplayOffset value:
+
+   ImFont* font = io.Fonts->AddFontFromFileTTF("font.ttf", size_pixels);
+   font->DisplayOffset.y = 1;   // Render 1 pixel down
+
+
+---------------------------------------
+ FREETYPE RASTERIZER, SMALL FONT SIZES
+---------------------------------------
+
+ Dear ImGui uses imstb_truetype.h to rasterize fonts (with optional oversampling).
+ This technique and its implementation are not ideal for fonts rendered at _small sizes_, which may appear a 
+ little blurry or hard to read. 
+
+ There is an implementation of the ImFontAtlas builder using FreeType that you can use in the misc/freetype/ folder.
+
+ FreeType supports auto-hinting which tends to improve the readability of small fonts.
+ Note that this code currently creates textures that are unoptimally too large (could be fixed with some work).
+ Also note that correct sRGB space blending will have an important effect on your font rendering quality.
+
+
+---------------------------------------
+ BUILDING CUSTOM GLYPH RANGES
+---------------------------------------
+
+ You can use the ImFontAtlas::GlyphRangesBuilder helper to create glyph ranges based on text input.
+ For example: for a game where your script is known, if you can feed your entire script to it and only build the characters the game needs. 
+
+   ImVector<ImWchar> ranges;
+   ImFontAtlas::GlyphRangesBuilder builder;
+   builder.AddText("Hello world");                        // Add a string (here "Hello world" contains 7 unique characters)
+   builder.AddChar(0x7262);                               // Add a specific character
+   builder.AddRanges(io.Fonts->GetGlyphRangesJapanese()); // Add one of the default ranges
+   builder.BuildRanges(&ranges);                          // Build the final result (ordered ranges with all the unique characters submitted)
+
+   io.Fonts->AddFontFromFileTTF("myfontfile.ttf", size_in_pixels, NULL, ranges.Data);
+   io.Fonts->Build();                                     // Build the atlas while 'ranges' is still in scope and not deleted.
+
+
+---------------------------------------
+ EMBEDDING FONTS IN SOURCE CODE
+---------------------------------------
+
+ Compile and use 'binary_to_compressed_c.cpp' to create a compressed C style array that you can embed in source code.
+ See the documentation in binary_to_compressed_c.cpp for instruction on how to use the tool.
+ You may find a precompiled version binary_to_compressed_c.exe for Windows instead of demo binaries package (see README).
+ The tool optionally used Base85 encoding to reduce the size of _source code_ but the read-only arrays will be about 20% bigger. 
+
+ Then load the font with:
+   ImFont* font = io.Fonts->AddFontFromMemoryCompressedTTF(compressed_data, compressed_data_size, size_pixels, ...);
+ or: 
+   ImFont* font = io.Fonts->AddFontFromMemoryCompressedBase85TTF(compressed_data_base85, size_pixels, ...);
+
+
+---------------------------------------
+ CREDITS/LICENSES FOR FONTS INCLUDED IN THIS FOLDER
+---------------------------------------
+
+ Roboto-Medium.ttf
+   Apache License 2.0
+   by Christian Robertson
+   https://fonts.google.com/specimen/Roboto
+
+ Cousine-Regular.ttf
+   by Steve Matteson
+   Digitized data copyright (c) 2010 Google Corporation.
+   Licensed under the SIL Open Font License, Version 1.1
+   https://fonts.google.com/specimen/Cousine 
+
+ DroidSans.ttf
+   Copyright (c) Steve Matteson
+   Apache License, version 2.0
+   https://www.fontsquirrel.com/fonts/droid-sans
+
+ ProggyClean.ttf
+   Copyright (c) 2004, 2005 Tristan Grimmer
+   MIT License
+   recommended loading setting in ImGui: Size = 13.0, DisplayOffset.Y = +1
+   http://www.proggyfonts.net/
+
+ ProggyTiny.ttf
+   Copyright (c) 2004, 2005 Tristan Grimmer
+   MIT License
+   recommended loading setting in ImGui: Size = 10.0, DisplayOffset.Y = +1
+   http://www.proggyfonts.net/
+
+ Karla-Regular.ttf
+   Copyright (c) 2012, Jonathan Pinhorn
+   SIL OPEN FONT LICENSE Version 1.1
+
+
+---------------------------------------
+ LINKS, OTHER FONTS
+---------------------------------------
+
+ (Icons) Icon fonts
+   https://fortawesome.github.io/Font-Awesome/
+   https://github.com/SamBrishes/kenney-icon-font
+   https://design.google.com/icons/
+   You can use https://github.com/juliettef/IconFontCppHeaders for C/C++ header files with name #define to access icon codepoint in source code.
+
+ (Icons) IcoMoon - Custom Icon font builder
+   https://icomoon.io/app
+
+ (Pixel perfect) Sweet16, Sweet16 Mono, by Martin Sedlak (Latin + Supplemental + Extended A)
+   https://github.com/kmar/Sweet16Font
+   Also include .inl file to use directly in dear imgui.
+
+ (Regular) Open Sans Fonts
+   https://fonts.google.com/specimen/Open+Sans
+
+ (Regular) Google Noto Fonts (worldwide languages)
+   https://www.google.com/get/noto/
+ 
+ (Monospace) Typefaces for source code beautification
+   https://github.com/chrissimpkins/codeface
+
+ (Monospace) Programmation fonts
+   http://s9w.github.io/font_compare/
+
+ (Monospace) Proggy Programming Fonts
+   http://upperbounds.net
+   
+ (Monospace) Inconsolata
+   http://www.levien.com/type/myfonts/inconsolata.html
+
+ (Monospace) Adobe Source Code Pro: Monospaced font family for user interface and coding environments
+   https://github.com/adobe-fonts/source-code-pro
+
+ (Monospace) Monospace/Fixed Width Programmer's Fonts
+   http://www.lowing.org/fonts/
+
+ (Japanese) M+ fonts by Coji Morishita are free and include most useful Kanjis you would need.
+   http://mplus-fonts.sourceforge.jp/mplus-outline-fonts/index-en.html
+
+ Or use Arial Unicode or other Unicode fonts provided with Windows for full characters coverage (not sure of their licensing).
+
diff --git a/3rdparty/imgui/misc/fonts/Roboto-Medium.ttf b/3rdparty/imgui/misc/fonts/Roboto-Medium.ttf
new file mode 100644
index 00000000..39c63d74
--- /dev/null
+++ b/3rdparty/imgui/misc/fonts/Roboto-Medium.ttf
diff --git a/3rdparty/imgui/misc/fonts/binary_to_compressed_c.cpp b/3rdparty/imgui/misc/fonts/binary_to_compressed_c.cpp
new file mode 100644
index 00000000..08b102d4
--- /dev/null
+++ b/3rdparty/imgui/misc/fonts/binary_to_compressed_c.cpp
@@ -0,0 +1,380 @@
+// ImGui - binary_to_compressed_c.cpp
+// Helper tool to turn a file into a C array, if you want to embed font data in your source code.
+
+// The data is first compressed with stb_compress() to reduce source code size,
+// then encoded in Base85 to fit in a string so we can fit roughly 4 bytes of compressed data into 5 bytes of source code (suggested by @mmalex)
+// (If we used 32-bits constants it would require take 11 bytes of source code to encode 4 bytes, and be endianness dependent)
+// Note that even with compression, the output array is likely to be bigger than the binary file..
+// Load compressed TTF fonts with ImGui::GetIO().Fonts->AddFontFromMemoryCompressedTTF()
+
+// Build with, e.g:
+//   # cl.exe binary_to_compressed_c.cpp
+//   # gcc binary_to_compressed_c.cpp
+// You can also find a precompiled Windows binary in the binary/demo package available from https://github.com/ocornut/imgui
+
+// Usage:
+//   binary_to_compressed_c.exe [-base85] [-nocompress] <inputfile> <symbolname>
+// Usage example:
+//   # binary_to_compressed_c.exe myfont.ttf MyFont > myfont.cpp
+//   # binary_to_compressed_c.exe -base85 myfont.ttf MyFont > myfont.cpp
+
+#define _CRT_SECURE_NO_WARNINGS
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <assert.h>
+
+// stb_compress* from stb.h - declaration
+typedef unsigned int stb_uint;
+typedef unsigned char stb_uchar;
+stb_uint stb_compress(stb_uchar *out,stb_uchar *in,stb_uint len);
+
+static bool binary_to_compressed_c(const char* filename, const char* symbol, bool use_base85_encoding, bool use_compression);
+
+int main(int argc, char** argv)
+{
+    if (argc < 3)
+    {
+        printf("Syntax: %s [-base85] [-nocompress] <inputfile> <symbolname>\n", argv[0]);
+        return 0;
+    }
+
+    int argn = 1;
+    bool use_base85_encoding = false;
+    bool use_compression = true;
+    if (argv[argn][0] == '-')
+    {
+        if (strcmp(argv[argn], "-base85") == 0) { use_base85_encoding = true; argn++; }
+        else if (strcmp(argv[argn], "-nocompress") == 0) { use_compression = false; argn++; }
+        else
+        {
+            printf("Unknown argument: '%s'\n", argv[argn]);
+            return 1;
+        }
+    }
+
+    return binary_to_compressed_c(argv[argn], argv[argn+1], use_base85_encoding, use_compression) ? 0 : 1;
+}
+
+char Encode85Byte(unsigned int x) 
+{
+    x = (x % 85) + 35;
+    return (x>='\\') ? x+1 : x;
+}
+
+bool binary_to_compressed_c(const char* filename, const char* symbol, bool use_base85_encoding, bool use_compression)
+{
+    // Read file
+    FILE* f = fopen(filename, "rb");
+    if (!f) return false;
+    int data_sz;
+    if (fseek(f, 0, SEEK_END) || (data_sz = (int)ftell(f)) == -1 || fseek(f, 0, SEEK_SET)) { fclose(f); return false; }
+    char* data = new char[data_sz+4];
+    if (fread(data, 1, data_sz, f) != (size_t)data_sz) { fclose(f); delete[] data; return false; }
+    memset((void*)(((char*)data) + data_sz), 0, 4);
+    fclose(f);
+
+    // Compress
+    int maxlen = data_sz + 512 + (data_sz >> 2) + sizeof(int); // total guess
+    char* compressed = use_compression ? new char[maxlen] : data;
+    int compressed_sz = use_compression ? stb_compress((stb_uchar*)compressed, (stb_uchar*)data, data_sz) : data_sz;
+    if (use_compression)
+		memset(compressed + compressed_sz, 0, maxlen - compressed_sz);
+
+    // Output as Base85 encoded
+    FILE* out = stdout;
+    fprintf(out, "// File: '%s' (%d bytes)\n", filename, (int)data_sz);
+    fprintf(out, "// Exported using binary_to_compressed_c.cpp\n");
+	const char* compressed_str = use_compression ? "compressed_" : "";
+    if (use_base85_encoding)
+    {
+        fprintf(out, "static const char %s_%sdata_base85[%d+1] =\n    \"", symbol, compressed_str, (int)((compressed_sz+3)/4)*5);
+        char prev_c = 0;
+        for (int src_i = 0; src_i < compressed_sz; src_i += 4)
+        {
+            // This is made a little more complicated by the fact that ??X sequences are interpreted as trigraphs by old C/C++ compilers. So we need to escape pairs of ??.
+            unsigned int d = *(unsigned int*)(compressed + src_i);
+            for (unsigned int n5 = 0; n5 < 5; n5++, d /= 85)
+            {
+                char c = Encode85Byte(d);
+                fprintf(out, (c == '?' && prev_c == '?') ? "\\%c" : "%c", c);
+                prev_c = c;
+            }
+            if ((src_i % 112) == 112-4)
+                fprintf(out, "\"\n    \"");
+        }
+        fprintf(out, "\";\n\n");
+    }
+    else
+    {
+        fprintf(out, "static const unsigned int %s_%ssize = %d;\n", symbol, compressed_str, (int)compressed_sz);
+        fprintf(out, "static const unsigned int %s_%sdata[%d/4] =\n{", symbol, compressed_str, (int)((compressed_sz+3)/4)*4);
+        int column = 0;
+        for (int i = 0; i < compressed_sz; i += 4)
+        {
+            unsigned int d = *(unsigned int*)(compressed + i);
+            if ((column++ % 12) == 0)
+                fprintf(out, "\n    0x%08x, ", d);
+            else
+                fprintf(out, "0x%08x, ", d);
+        }
+        fprintf(out, "\n};\n\n");
+    }
+
+    // Cleanup
+    delete[] data;
+    if (use_compression)
+	    delete[] compressed;
+    return true;
+}
+
+// stb_compress* from stb.h - definition
+
+////////////////////           compressor         ///////////////////////
+
+static stb_uint stb_adler32(stb_uint adler32, stb_uchar *buffer, stb_uint buflen)
+{
+    const unsigned long ADLER_MOD = 65521;
+    unsigned long s1 = adler32 & 0xffff, s2 = adler32 >> 16;
+    unsigned long blocklen, i;
+
+    blocklen = buflen % 5552;
+    while (buflen) {
+        for (i=0; i + 7 < blocklen; i += 8) {
+            s1 += buffer[0], s2 += s1;
+            s1 += buffer[1], s2 += s1;
+            s1 += buffer[2], s2 += s1;
+            s1 += buffer[3], s2 += s1;
+            s1 += buffer[4], s2 += s1;
+            s1 += buffer[5], s2 += s1;
+            s1 += buffer[6], s2 += s1;
+            s1 += buffer[7], s2 += s1;
+
+            buffer += 8;
+        }
+
+        for (; i < blocklen; ++i)
+            s1 += *buffer++, s2 += s1;
+
+        s1 %= ADLER_MOD, s2 %= ADLER_MOD;
+        buflen -= blocklen;
+        blocklen = 5552;
+    }
+    return (s2 << 16) + s1;
+}
+
+static unsigned int stb_matchlen(stb_uchar *m1, stb_uchar *m2, stb_uint maxlen)
+{
+    stb_uint i;
+    for (i=0; i < maxlen; ++i)
+        if (m1[i] != m2[i]) return i;
+    return i;
+}
+
+// simple implementation that just takes the source data in a big block
+
+static stb_uchar *stb__out;
+static FILE      *stb__outfile;
+static stb_uint   stb__outbytes;
+
+static void stb__write(unsigned char v)
+{
+    fputc(v, stb__outfile);
+    ++stb__outbytes;
+}
+
+//#define stb_out(v)    (stb__out ? *stb__out++ = (stb_uchar) (v) : stb__write((stb_uchar) (v)))
+#define stb_out(v)    do { if (stb__out) *stb__out++ = (stb_uchar) (v); else stb__write((stb_uchar) (v)); } while (0)
+
+static void stb_out2(stb_uint v) { stb_out(v >> 8); stb_out(v); }
+static void stb_out3(stb_uint v) { stb_out(v >> 16); stb_out(v >> 8); stb_out(v); }
+static void stb_out4(stb_uint v) { stb_out(v >> 24); stb_out(v >> 16); stb_out(v >> 8 ); stb_out(v); }
+
+static void outliterals(stb_uchar *in, int numlit)
+{
+    while (numlit > 65536) {
+        outliterals(in,65536);
+        in     += 65536;
+        numlit -= 65536;
+    }
+
+    if      (numlit ==     0)    ;
+    else if (numlit <=    32)    stb_out (0x000020 + numlit-1);
+    else if (numlit <=  2048)    stb_out2(0x000800 + numlit-1);
+    else /*  numlit <= 65536) */ stb_out3(0x070000 + numlit-1);
+
+    if (stb__out) {
+        memcpy(stb__out,in,numlit);
+        stb__out += numlit;
+    } else
+        fwrite(in, 1, numlit, stb__outfile);
+}
+
+static int stb__window = 0x40000; // 256K
+
+static int stb_not_crap(int best, int dist)
+{
+    return   ((best > 2  &&  dist <= 0x00100)     
+        || (best > 5  &&  dist <= 0x04000)
+        || (best > 7  &&  dist <= 0x80000));
+}
+
+static  stb_uint stb__hashsize = 32768;
+
+// note that you can play with the hashing functions all you
+// want without needing to change the decompressor
+#define stb__hc(q,h,c)      (((h) << 7) + ((h) >> 25) + q[c])
+#define stb__hc2(q,h,c,d)   (((h) << 14) + ((h) >> 18) + (q[c] << 7) + q[d])
+#define stb__hc3(q,c,d,e)   ((q[c] << 14) + (q[d] << 7) + q[e])
+
+static unsigned int stb__running_adler;
+
+static int stb_compress_chunk(stb_uchar *history,
+    stb_uchar *start,
+    stb_uchar *end,
+    int length,
+    int *pending_literals,
+    stb_uchar **chash,
+    stb_uint mask)
+{
+    (void)history;
+    int window = stb__window;
+    stb_uint match_max;
+    stb_uchar *lit_start = start - *pending_literals;
+    stb_uchar *q = start;
+
+#define STB__SCRAMBLE(h)   (((h) + ((h) >> 16)) & mask)
+
+    // stop short of the end so we don't scan off the end doing
+    // the hashing; this means we won't compress the last few bytes
+    // unless they were part of something longer
+    while (q < start+length && q+12 < end) {
+        int m;
+        stb_uint h1,h2,h3,h4, h;
+        stb_uchar *t;
+        int best = 2, dist=0;
+
+        if (q+65536 > end)
+            match_max = end-q;
+        else
+            match_max = 65536;
+
+#define stb__nc(b,d)  ((d) <= window && ((b) > 9 || stb_not_crap(b,d)))
+
+#define STB__TRY(t,p)  /* avoid retrying a match we already tried */ \
+    if (p ? dist != q-t : 1)                             \
+    if ((m = stb_matchlen(t, q, match_max)) > best)     \
+    if (stb__nc(m,q-(t)))                                \
+    best = m, dist = q - (t)
+
+        // rather than search for all matches, only try 4 candidate locations,
+        // chosen based on 4 different hash functions of different lengths.
+        // this strategy is inspired by LZO; hashing is unrolled here using the
+        // 'hc' macro
+        h = stb__hc3(q,0, 1, 2); h1 = STB__SCRAMBLE(h);
+        t = chash[h1]; if (t) STB__TRY(t,0);
+        h = stb__hc2(q,h, 3, 4); h2 = STB__SCRAMBLE(h);
+        h = stb__hc2(q,h, 5, 6);        t = chash[h2]; if (t) STB__TRY(t,1);
+        h = stb__hc2(q,h, 7, 8); h3 = STB__SCRAMBLE(h);
+        h = stb__hc2(q,h, 9,10);        t = chash[h3]; if (t) STB__TRY(t,1);
+        h = stb__hc2(q,h,11,12); h4 = STB__SCRAMBLE(h);
+        t = chash[h4]; if (t) STB__TRY(t,1);
+
+        // because we use a shared hash table, can only update it
+        // _after_ we've probed all of them
+        chash[h1] = chash[h2] = chash[h3] = chash[h4] = q;
+
+        if (best > 2)
+            assert(dist > 0);
+
+        // see if our best match qualifies
+        if (best < 3) { // fast path literals
+            ++q;
+        } else if (best > 2  &&  best <= 0x80    &&  dist <= 0x100) {
+            outliterals(lit_start, q-lit_start); lit_start = (q += best);
+            stb_out(0x80 + best-1);
+            stb_out(dist-1);
+        } else if (best > 5  &&  best <= 0x100   &&  dist <= 0x4000) {
+            outliterals(lit_start, q-lit_start); lit_start = (q += best);
+            stb_out2(0x4000 + dist-1);       
+            stb_out(best-1);
+        } else if (best > 7  &&  best <= 0x100   &&  dist <= 0x80000) {
+            outliterals(lit_start, q-lit_start); lit_start = (q += best);
+            stb_out3(0x180000 + dist-1);     
+            stb_out(best-1);
+        } else if (best > 8  &&  best <= 0x10000 &&  dist <= 0x80000) {
+            outliterals(lit_start, q-lit_start); lit_start = (q += best);
+            stb_out3(0x100000 + dist-1);     
+            stb_out2(best-1);
+        } else if (best > 9                      &&  dist <= 0x1000000) {
+            if (best > 65536) best = 65536;
+            outliterals(lit_start, q-lit_start); lit_start = (q += best);
+            if (best <= 0x100) {
+                stb_out(0x06);
+                stb_out3(dist-1);
+                stb_out(best-1);
+            } else {
+                stb_out(0x04);
+                stb_out3(dist-1);
+                stb_out2(best-1);
+            }
+        } else {  // fallback literals if no match was a balanced tradeoff
+            ++q;
+        }
+    }
+
+    // if we didn't get all the way, add the rest to literals
+    if (q-start < length)
+        q = start+length;
+
+    // the literals are everything from lit_start to q
+    *pending_literals = (q - lit_start);
+
+    stb__running_adler = stb_adler32(stb__running_adler, start, q - start);
+    return q - start;
+}
+
+static int stb_compress_inner(stb_uchar *input, stb_uint length)
+{
+    int literals = 0;
+    stb_uint len,i;
+
+    stb_uchar **chash;
+    chash = (stb_uchar**) malloc(stb__hashsize * sizeof(stb_uchar*));
+    if (chash == NULL) return 0; // failure
+    for (i=0; i < stb__hashsize; ++i)
+        chash[i] = NULL;
+
+    // stream signature
+    stb_out(0x57); stb_out(0xbc);
+    stb_out2(0);
+
+    stb_out4(0);       // 64-bit length requires 32-bit leading 0
+    stb_out4(length);
+    stb_out4(stb__window);
+
+    stb__running_adler = 1;
+
+    len = stb_compress_chunk(input, input, input+length, length, &literals, chash, stb__hashsize-1);
+    assert(len == length);
+
+    outliterals(input+length - literals, literals);
+
+    free(chash);
+
+    stb_out2(0x05fa); // end opcode
+
+    stb_out4(stb__running_adler);
+
+    return 1; // success
+}
+
+stb_uint stb_compress(stb_uchar *out, stb_uchar *input, stb_uint length)
+{
+    stb__out = out;
+    stb__outfile = NULL;
+
+    stb_compress_inner(input, length);
+
+    return stb__out - out;
+}