Conflicts: examples/directx11_example/imgui_impl_dx11.cpp imgui.cppfeatures/sdl_renderer3_multiviewports
ocornut
ago%!(EXTRA string=11 years)
commit
43cb4038c6
6 changed files with 497 additions and 80 deletions
@ -0,0 +1,330 @@ |
||||
// ImGui - binary_to_compressed_c.cpp
|
||||
// Helper tool to turn a file into a C array.
|
||||
// The data is first compressed with stb_compress() to reduce source code size a little.
|
||||
// Useful if you want to embed fonts into your code.
|
||||
// Note that the output array is likely to be bigger than the binary file..
|
||||
// Load compressed TTF fonts with ImGui::GetIO().Fonts->AddFontFromMemoryCompressedTTF()
|
||||
|
||||
#define _CRT_SECURE_NO_WARNINGS |
||||
#include <stdio.h> |
||||
#include <string.h> |
||||
#include <stdlib.h> |
||||
#include <assert.h> |
||||
|
||||
const int COLUMNS = 12; |
||||
|
||||
// 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); |
||||
|
||||
int main(int argc, char** argv) |
||||
{ |
||||
if (argc < 3) |
||||
{ |
||||
printf("Syntax: %s <inputfile> <symbolname>\n", argv[0]); |
||||
return 0; |
||||
} |
||||
|
||||
binary_to_compressed_c(argv[1], argv[2]); |
||||
return 1; |
||||
} |
||||
|
||||
bool binary_to_compressed_c(const char* filename, const char* symbol) |
||||
{ |
||||
// 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 = new char[maxlen]; |
||||
int compressed_sz = stb_compress((stb_uchar*)compressed, (stb_uchar*)data, data_sz); |
||||
memset(compressed + compressed_sz, 0, maxlen - compressed_sz); |
||||
|
||||
// Output
|
||||
FILE* out = stdout; |
||||
fprintf(out, "// File: '%s' (%d bytes)\n", filename, (int)data_sz); |
||||
fprintf(out, "// Exported using binary_to_compressed_c\n"); |
||||
fprintf(out, "static const unsigned int %s_compressed_size = %d;\n", symbol, (int)compressed_sz); |
||||
fprintf(out, "static const unsigned int %s_compressed_data[%d/4] =\n{", symbol, (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++ % COLUMNS) == 0) |
||||
fprintf(out, "\n 0x%08x, ", d); |
||||
else |
||||
fprintf(out, "0x%08x, ", d); |
||||
} |
||||
fprintf(out, "\n};\n\n"); |
||||
|
||||
// Cleanup
|
||||
delete[] data; |
||||
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))) |
||||
|
||||
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; |
||||
} |
||||
Loading…
Reference in New Issue