forked from Mirror/GodMode9
Replace QLZ with PCX for splash
This commit is contained in:
Wolfvak
d0k3
parent
c63a6e26c8
commit
0220230403
@ -7,7 +7,7 @@ rwildcard = $(foreach d, $(wildcard $1*), \
|
|||||||
|
|
||||||
FLAVOR ?= GodMode9
|
FLAVOR ?= GodMode9
|
||||||
README := README.md
|
README := README.md
|
||||||
SPLASH = resources/$(FLAVOR)_splash.qlz
|
SPLASH = resources/$(FLAVOR)_splash.pcx
|
||||||
|
|
||||||
ifeq ($(FONT),ORIG)
|
ifeq ($(FONT),ORIG)
|
||||||
CFLAGS += -DFONT_ORIGINAL
|
CFLAGS += -DFONT_ORIGINAL
|
||||||
|
|||||||
@ -52,6 +52,10 @@ void DrawRectangle(u8* screen, int x, int y, int width, int height, int color)
|
|||||||
|
|
||||||
void DrawBitmap(u8* screen, int x, int y, int w, int h, u8* bitmap)
|
void DrawBitmap(u8* screen, int x, int y, int w, int h, u8* bitmap)
|
||||||
{
|
{
|
||||||
|
// on negative values: center the bitmap
|
||||||
|
if (x < 0) x = (SCREEN_WIDTH(screen) - w) >> 1;
|
||||||
|
if (y < 0) y = (SCREEN_HEIGHT - h) >> 1;
|
||||||
|
|
||||||
u8* bitmapPos = bitmap;
|
u8* bitmapPos = bitmap;
|
||||||
for (int yy = 0; yy < h; yy++) {
|
for (int yy = 0; yy < h; yy++) {
|
||||||
int xDisplacement = (x * BYTES_PER_PIXEL * SCREEN_HEIGHT);
|
int xDisplacement = (x * BYTES_PER_PIXEL * SCREEN_HEIGHT);
|
||||||
@ -319,7 +323,7 @@ bool ShowPrompt(bool ask, const char *format, ...)
|
|||||||
#ifndef AUTO_UNLOCK
|
#ifndef AUTO_UNLOCK
|
||||||
#define PRNG (*(volatile u32*)0x10011000)
|
#define PRNG (*(volatile u32*)0x10011000)
|
||||||
bool ShowUnlockSequence(u32 seqlvl, const char *format, ...) {
|
bool ShowUnlockSequence(u32 seqlvl, const char *format, ...) {
|
||||||
const char dpad_symbols[] = { '\x1A', '\x1B', '\x18', '\x19' }; // R L D U
|
const char dpad_symbols[] = { '\x1A', '\x1B', '\x18', '\x19' }; // R L U D
|
||||||
const int seqcolors[7] = { COLOR_STD_FONT, COLOR_BRIGHTGREEN, COLOR_BRIGHTYELLOW,
|
const int seqcolors[7] = { COLOR_STD_FONT, COLOR_BRIGHTGREEN, COLOR_BRIGHTYELLOW,
|
||||||
COLOR_ORANGE, COLOR_BRIGHTBLUE, COLOR_RED, COLOR_DARKRED };
|
COLOR_ORANGE, COLOR_BRIGHTBLUE, COLOR_RED, COLOR_DARKRED };
|
||||||
const u32 seqlen_max = 7;
|
const u32 seqlen_max = 7;
|
||||||
|
|||||||
@ -10,7 +10,7 @@
|
|||||||
#include "unittype.h"
|
#include "unittype.h"
|
||||||
#include "entrypoints.h"
|
#include "entrypoints.h"
|
||||||
#include "bootfirm.h"
|
#include "bootfirm.h"
|
||||||
#include "qlzcomp.h"
|
#include "pcx.h"
|
||||||
#include "timer.h"
|
#include "timer.h"
|
||||||
#include "rtc.h"
|
#include "rtc.h"
|
||||||
#include "power.h"
|
#include "power.h"
|
||||||
@ -48,7 +48,8 @@ static PaneData* panedata = (PaneData*) (DIR_BUFFER + 0xF0000);
|
|||||||
|
|
||||||
|
|
||||||
u32 SplashInit(const char* modestr) {
|
u32 SplashInit(const char* modestr) {
|
||||||
void* splash = FindVTarFileInfo(VRAM0_SPLASH_QLZ, NULL);
|
u64 splash_size;
|
||||||
|
u8* splash = FindVTarFileInfo(VRAM0_SPLASH_PCX, &splash_size);
|
||||||
const char* namestr = FLAVOR " " VERSION;
|
const char* namestr = FLAVOR " " VERSION;
|
||||||
const char* loadstr = "booting...";
|
const char* loadstr = "booting...";
|
||||||
const u32 pos_xb = 10;
|
const u32 pos_xb = 10;
|
||||||
@ -57,8 +58,11 @@ u32 SplashInit(const char* modestr) {
|
|||||||
const u32 pos_yu = SCREEN_HEIGHT - 10 - GetDrawStringHeight(loadstr);
|
const u32 pos_yu = SCREEN_HEIGHT - 10 - GetDrawStringHeight(loadstr);
|
||||||
|
|
||||||
ClearScreenF(true, true, COLOR_STD_BG);
|
ClearScreenF(true, true, COLOR_STD_BG);
|
||||||
if (splash) QlzDecompress(TOP_SCREEN, splash, 0);
|
|
||||||
else DrawStringF(TOP_SCREEN, 10, 10, COLOR_STD_FONT, COLOR_TRANSPARENT, "(" VRAM0_SPLASH_QLZ " not found)");
|
if (splash && PCX_Decompress(TEMP_BUFFER, TEMP_BUFFER_SIZE, splash, splash_size)) {
|
||||||
|
PCXHdr* hdr = (PCXHdr*) (void*) splash;
|
||||||
|
DrawBitmap(TOP_SCREEN, -1, -1, PCX_Width(hdr), PCX_Height(hdr), TEMP_BUFFER);
|
||||||
|
} else DrawStringF(TOP_SCREEN, 10, 10, COLOR_STD_FONT, COLOR_TRANSPARENT, "(" VRAM0_SPLASH_PCX " not found)");
|
||||||
if (modestr) DrawStringF(TOP_SCREEN, SCREEN_WIDTH_TOP - 10 - GetDrawStringWidth(modestr),
|
if (modestr) DrawStringF(TOP_SCREEN, SCREEN_WIDTH_TOP - 10 - GetDrawStringWidth(modestr),
|
||||||
SCREEN_HEIGHT - 10 - GetDrawStringHeight(modestr), COLOR_STD_FONT, COLOR_TRANSPARENT, modestr);
|
SCREEN_HEIGHT - 10 - GetDrawStringHeight(modestr), COLOR_STD_FONT, COLOR_TRANSPARENT, modestr);
|
||||||
|
|
||||||
|
|||||||
@ -1,17 +0,0 @@
|
|||||||
#include "qlzcomp.h"
|
|
||||||
#include "quicklz.h"
|
|
||||||
|
|
||||||
u32 QlzCompress(void* out, const void* in, u32 size_in) {
|
|
||||||
if (TEMP_BUFFER_SIZE < sizeof(qlz_state_compress)) return 1;
|
|
||||||
qlz_state_compress *state_compress = (qlz_state_compress*) (void*) TEMP_BUFFER;
|
|
||||||
memset(state_compress, 0, sizeof(qlz_state_compress));
|
|
||||||
return (qlz_compress(in, out, size_in, state_compress) > 0) ? 0 : 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
u32 QlzDecompress(void* out, const void* in, u32 size_out) {
|
|
||||||
if (TEMP_BUFFER_SIZE < sizeof(qlz_state_decompress)) return 1;
|
|
||||||
if (size_out && (qlz_size_decompressed(in) != size_out)) return 1;
|
|
||||||
qlz_state_decompress *state_decompress = (qlz_state_decompress*) (void*) TEMP_BUFFER;
|
|
||||||
memset(state_decompress, 0, sizeof(qlz_state_decompress));
|
|
||||||
return (qlz_decompress(in, out, state_decompress) > 0) ? 0 : 1;
|
|
||||||
}
|
|
||||||
@ -1,6 +0,0 @@
|
|||||||
#pragma once
|
|
||||||
|
|
||||||
#include "common.h"
|
|
||||||
|
|
||||||
u32 QlzCompress(void* out, const void* in, u32 size_decomp);
|
|
||||||
u32 QlzDecompress(void* out, const void* in, u32 size);
|
|
||||||
@ -1,848 +0,0 @@
|
|||||||
// Fast data compression library
|
|
||||||
// Copyright (C) 2006-2011 Lasse Mikkel Reinhold
|
|
||||||
// lar@quicklz.com
|
|
||||||
//
|
|
||||||
// QuickLZ can be used for free under the GPL 1, 2 or 3 license (where anything
|
|
||||||
// released into public must be open source) or under a commercial license if such
|
|
||||||
// has been acquired (see http://www.quicklz.com/order.html). The commercial license
|
|
||||||
// does not cover derived or ported versions created by third parties under GPL.
|
|
||||||
|
|
||||||
// 1.5.0 final
|
|
||||||
|
|
||||||
#include "quicklz.h"
|
|
||||||
|
|
||||||
#if QLZ_VERSION_MAJOR != 1 || QLZ_VERSION_MINOR != 5 || QLZ_VERSION_REVISION != 0
|
|
||||||
#error quicklz.c and quicklz.h have different versions
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if (defined(__X86__) || defined(__i386__) || defined(i386) || defined(_M_IX86) || defined(__386__) || defined(__x86_64__) || defined(_M_X64))
|
|
||||||
#define X86X64
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#define MINOFFSET 2
|
|
||||||
#define UNCONDITIONAL_MATCHLEN 6
|
|
||||||
#define UNCOMPRESSED_END 4
|
|
||||||
#define CWORD_LEN 4
|
|
||||||
|
|
||||||
#if QLZ_COMPRESSION_LEVEL == 1 && defined QLZ_PTR_64 && QLZ_STREAMING_BUFFER == 0
|
|
||||||
#define OFFSET_BASE source
|
|
||||||
#define CAST (ui32)(size_t)
|
|
||||||
#else
|
|
||||||
#define OFFSET_BASE 0
|
|
||||||
#define CAST
|
|
||||||
#endif
|
|
||||||
|
|
||||||
int qlz_get_setting(int setting)
|
|
||||||
{
|
|
||||||
switch (setting)
|
|
||||||
{
|
|
||||||
case 0: return QLZ_COMPRESSION_LEVEL;
|
|
||||||
case 1: return sizeof(qlz_state_compress);
|
|
||||||
case 2: return sizeof(qlz_state_decompress);
|
|
||||||
case 3: return QLZ_STREAMING_BUFFER;
|
|
||||||
#ifdef QLZ_MEMORY_SAFE
|
|
||||||
case 6: return 1;
|
|
||||||
#else
|
|
||||||
case 6: return 0;
|
|
||||||
#endif
|
|
||||||
case 7: return QLZ_VERSION_MAJOR;
|
|
||||||
case 8: return QLZ_VERSION_MINOR;
|
|
||||||
case 9: return QLZ_VERSION_REVISION;
|
|
||||||
}
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
#if QLZ_COMPRESSION_LEVEL == 1
|
|
||||||
static int same(const unsigned char *src, size_t n)
|
|
||||||
{
|
|
||||||
while(n > 0 && *(src + n) == *src)
|
|
||||||
n--;
|
|
||||||
return n == 0 ? 1 : 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
static void reset_table_compress(qlz_state_compress *state)
|
|
||||||
{
|
|
||||||
int i;
|
|
||||||
for(i = 0; i < QLZ_HASH_VALUES; i++)
|
|
||||||
{
|
|
||||||
#if QLZ_COMPRESSION_LEVEL == 1
|
|
||||||
state->hash[i].offset = 0;
|
|
||||||
#else
|
|
||||||
state->hash_counter[i] = 0;
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
static void reset_table_decompress(qlz_state_decompress *state)
|
|
||||||
{
|
|
||||||
int i;
|
|
||||||
(void)state;
|
|
||||||
(void)i;
|
|
||||||
#if QLZ_COMPRESSION_LEVEL == 2
|
|
||||||
for(i = 0; i < QLZ_HASH_VALUES; i++)
|
|
||||||
{
|
|
||||||
state->hash_counter[i] = 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
static __inline ui32 hash_func(ui32 i)
|
|
||||||
{
|
|
||||||
#if QLZ_COMPRESSION_LEVEL == 2
|
|
||||||
return ((i >> 9) ^ (i >> 13) ^ i) & (QLZ_HASH_VALUES - 1);
|
|
||||||
#else
|
|
||||||
return ((i >> 12) ^ i) & (QLZ_HASH_VALUES - 1);
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
static __inline ui32 fast_read(void const *src, ui32 bytes)
|
|
||||||
{
|
|
||||||
#ifndef X86X64
|
|
||||||
unsigned char *p = (unsigned char*)src;
|
|
||||||
switch (bytes)
|
|
||||||
{
|
|
||||||
case 4:
|
|
||||||
return(*p | *(p + 1) << 8 | *(p + 2) << 16 | *(p + 3) << 24);
|
|
||||||
case 3:
|
|
||||||
return(*p | *(p + 1) << 8 | *(p + 2) << 16);
|
|
||||||
case 2:
|
|
||||||
return(*p | *(p + 1) << 8);
|
|
||||||
case 1:
|
|
||||||
return(*p);
|
|
||||||
}
|
|
||||||
return 0;
|
|
||||||
#else
|
|
||||||
if (bytes >= 1 && bytes <= 4)
|
|
||||||
return *((ui32*)src);
|
|
||||||
else
|
|
||||||
return 0;
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
static __inline ui32 hashat(const unsigned char *src)
|
|
||||||
{
|
|
||||||
ui32 fetch, hash;
|
|
||||||
fetch = fast_read(src, 3);
|
|
||||||
hash = hash_func(fetch);
|
|
||||||
return hash;
|
|
||||||
}
|
|
||||||
|
|
||||||
static __inline void fast_write(ui32 f, void *dst, size_t bytes)
|
|
||||||
{
|
|
||||||
#ifndef X86X64
|
|
||||||
unsigned char *p = (unsigned char*)dst;
|
|
||||||
|
|
||||||
switch (bytes)
|
|
||||||
{
|
|
||||||
case 4:
|
|
||||||
*p = (unsigned char)f;
|
|
||||||
*(p + 1) = (unsigned char)(f >> 8);
|
|
||||||
*(p + 2) = (unsigned char)(f >> 16);
|
|
||||||
*(p + 3) = (unsigned char)(f >> 24);
|
|
||||||
return;
|
|
||||||
case 3:
|
|
||||||
*p = (unsigned char)f;
|
|
||||||
*(p + 1) = (unsigned char)(f >> 8);
|
|
||||||
*(p + 2) = (unsigned char)(f >> 16);
|
|
||||||
return;
|
|
||||||
case 2:
|
|
||||||
*p = (unsigned char)f;
|
|
||||||
*(p + 1) = (unsigned char)(f >> 8);
|
|
||||||
return;
|
|
||||||
case 1:
|
|
||||||
*p = (unsigned char)f;
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
#else
|
|
||||||
switch (bytes)
|
|
||||||
{
|
|
||||||
case 4:
|
|
||||||
*((ui32*)dst) = f;
|
|
||||||
return;
|
|
||||||
case 3:
|
|
||||||
*((ui32*)dst) = f;
|
|
||||||
return;
|
|
||||||
case 2:
|
|
||||||
*((ui16 *)dst) = (ui16)f;
|
|
||||||
return;
|
|
||||||
case 1:
|
|
||||||
*((unsigned char*)dst) = (unsigned char)f;
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
size_t qlz_size_decompressed(const char *source)
|
|
||||||
{
|
|
||||||
ui32 n, r;
|
|
||||||
n = (((*source) & 2) == 2) ? 4 : 1;
|
|
||||||
r = fast_read(source + 1 + n, n);
|
|
||||||
r = r & (0xffffffff >> ((4 - n)*8));
|
|
||||||
return r;
|
|
||||||
}
|
|
||||||
|
|
||||||
size_t qlz_size_compressed(const char *source)
|
|
||||||
{
|
|
||||||
ui32 n, r;
|
|
||||||
n = (((*source) & 2) == 2) ? 4 : 1;
|
|
||||||
r = fast_read(source + 1, n);
|
|
||||||
r = r & (0xffffffff >> ((4 - n)*8));
|
|
||||||
return r;
|
|
||||||
}
|
|
||||||
|
|
||||||
size_t qlz_size_header(const char *source)
|
|
||||||
{
|
|
||||||
size_t n = 2*((((*source) & 2) == 2) ? 4 : 1) + 1;
|
|
||||||
return n;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static __inline void memcpy_up(unsigned char *dst, const unsigned char *src, ui32 n)
|
|
||||||
{
|
|
||||||
// Caution if modifying memcpy_up! Overlap of dst and src must be special handled.
|
|
||||||
#ifndef X86X64
|
|
||||||
unsigned char *end = dst + n;
|
|
||||||
while(dst < end)
|
|
||||||
{
|
|
||||||
*dst = *src;
|
|
||||||
dst++;
|
|
||||||
src++;
|
|
||||||
}
|
|
||||||
#else
|
|
||||||
ui32 f = 0;
|
|
||||||
do
|
|
||||||
{
|
|
||||||
*(ui32 *)(dst + f) = *(ui32 *)(src + f);
|
|
||||||
f += MINOFFSET + 1;
|
|
||||||
}
|
|
||||||
while (f < n);
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
static __inline void update_hash(qlz_state_decompress *state, const unsigned char *s)
|
|
||||||
{
|
|
||||||
#if QLZ_COMPRESSION_LEVEL == 1
|
|
||||||
ui32 hash;
|
|
||||||
hash = hashat(s);
|
|
||||||
state->hash[hash].offset = s;
|
|
||||||
state->hash_counter[hash] = 1;
|
|
||||||
#elif QLZ_COMPRESSION_LEVEL == 2
|
|
||||||
ui32 hash;
|
|
||||||
unsigned char c;
|
|
||||||
hash = hashat(s);
|
|
||||||
c = state->hash_counter[hash];
|
|
||||||
state->hash[hash].offset[c & (QLZ_POINTERS - 1)] = s;
|
|
||||||
c++;
|
|
||||||
state->hash_counter[hash] = c;
|
|
||||||
#endif
|
|
||||||
(void)state;
|
|
||||||
(void)s;
|
|
||||||
}
|
|
||||||
|
|
||||||
#if QLZ_COMPRESSION_LEVEL <= 2
|
|
||||||
static void update_hash_upto(qlz_state_decompress *state, unsigned char **lh, const unsigned char *max)
|
|
||||||
{
|
|
||||||
while(*lh < max)
|
|
||||||
{
|
|
||||||
(*lh)++;
|
|
||||||
update_hash(state, *lh);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
static size_t qlz_compress_core(const unsigned char *source, unsigned char *destination, size_t size, qlz_state_compress *state)
|
|
||||||
{
|
|
||||||
const unsigned char *last_byte = source + size - 1;
|
|
||||||
const unsigned char *src = source;
|
|
||||||
unsigned char *cword_ptr = destination;
|
|
||||||
unsigned char *dst = destination + CWORD_LEN;
|
|
||||||
ui32 cword_val = 1U << 31;
|
|
||||||
const unsigned char *last_matchstart = last_byte - UNCONDITIONAL_MATCHLEN - UNCOMPRESSED_END;
|
|
||||||
ui32 fetch = 0;
|
|
||||||
unsigned int lits = 0;
|
|
||||||
|
|
||||||
(void) lits;
|
|
||||||
|
|
||||||
if(src <= last_matchstart)
|
|
||||||
fetch = fast_read(src, 3);
|
|
||||||
|
|
||||||
while(src <= last_matchstart)
|
|
||||||
{
|
|
||||||
if ((cword_val & 1) == 1)
|
|
||||||
{
|
|
||||||
// store uncompressed if compression ratio is too low
|
|
||||||
if (src > source + (size >> 1) && dst - destination > src - source - ((src - source) >> 5))
|
|
||||||
return 0;
|
|
||||||
|
|
||||||
fast_write((cword_val >> 1) | (1U << 31), cword_ptr, CWORD_LEN);
|
|
||||||
|
|
||||||
cword_ptr = dst;
|
|
||||||
dst += CWORD_LEN;
|
|
||||||
cword_val = 1U << 31;
|
|
||||||
fetch = fast_read(src, 3);
|
|
||||||
}
|
|
||||||
#if QLZ_COMPRESSION_LEVEL == 1
|
|
||||||
{
|
|
||||||
const unsigned char *o;
|
|
||||||
ui32 hash, cached;
|
|
||||||
|
|
||||||
hash = hash_func(fetch);
|
|
||||||
cached = fetch ^ state->hash[hash].cache;
|
|
||||||
state->hash[hash].cache = fetch;
|
|
||||||
|
|
||||||
o = state->hash[hash].offset + OFFSET_BASE;
|
|
||||||
state->hash[hash].offset = CAST(src - OFFSET_BASE);
|
|
||||||
|
|
||||||
#ifdef X86X64
|
|
||||||
if ((cached & 0xffffff) == 0 && o != OFFSET_BASE && (src - o > MINOFFSET || (src == o + 1 && lits >= 3 && src > source + 3 && same(src - 3, 6))))
|
|
||||||
{
|
|
||||||
if(cached != 0)
|
|
||||||
{
|
|
||||||
#else
|
|
||||||
if (cached == 0 && o != OFFSET_BASE && (src - o > MINOFFSET || (src == o + 1 && lits >= 3 && src > source + 3 && same(src - 3, 6))))
|
|
||||||
{
|
|
||||||
if (*(o + 3) != *(src + 3))
|
|
||||||
{
|
|
||||||
#endif
|
|
||||||
hash <<= 4;
|
|
||||||
cword_val = (cword_val >> 1) | (1U << 31);
|
|
||||||
fast_write((3 - 2) | hash, dst, 2);
|
|
||||||
src += 3;
|
|
||||||
dst += 2;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
const unsigned char *old_src = src;
|
|
||||||
size_t matchlen;
|
|
||||||
hash <<= 4;
|
|
||||||
|
|
||||||
cword_val = (cword_val >> 1) | (1U << 31);
|
|
||||||
src += 4;
|
|
||||||
|
|
||||||
if(*(o + (src - old_src)) == *src)
|
|
||||||
{
|
|
||||||
src++;
|
|
||||||
if(*(o + (src - old_src)) == *src)
|
|
||||||
{
|
|
||||||
size_t q = last_byte - UNCOMPRESSED_END - (src - 5) + 1;
|
|
||||||
size_t remaining = q > 255 ? 255 : q;
|
|
||||||
src++;
|
|
||||||
while(*(o + (src - old_src)) == *src && (size_t)(src - old_src) < remaining)
|
|
||||||
src++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
matchlen = src - old_src;
|
|
||||||
if (matchlen < 18)
|
|
||||||
{
|
|
||||||
fast_write((ui32)(matchlen - 2) | hash, dst, 2);
|
|
||||||
dst += 2;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
fast_write((ui32)(matchlen << 16) | hash, dst, 3);
|
|
||||||
dst += 3;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
fetch = fast_read(src, 3);
|
|
||||||
lits = 0;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
lits++;
|
|
||||||
*dst = *src;
|
|
||||||
src++;
|
|
||||||
dst++;
|
|
||||||
cword_val = (cword_val >> 1);
|
|
||||||
#ifdef X86X64
|
|
||||||
fetch = fast_read(src, 3);
|
|
||||||
#else
|
|
||||||
fetch = (fetch >> 8 & 0xffff) | (*(src + 2) << 16);
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
}
|
|
||||||
#elif QLZ_COMPRESSION_LEVEL >= 2
|
|
||||||
{
|
|
||||||
const unsigned char *o, *offset2;
|
|
||||||
ui32 hash, matchlen, k, m, best_k = 0;
|
|
||||||
unsigned char c;
|
|
||||||
size_t remaining = (last_byte - UNCOMPRESSED_END - src + 1) > 255 ? 255 : (last_byte - UNCOMPRESSED_END - src + 1);
|
|
||||||
(void)best_k;
|
|
||||||
|
|
||||||
|
|
||||||
//hash = hashat(src);
|
|
||||||
fetch = fast_read(src, 3);
|
|
||||||
hash = hash_func(fetch);
|
|
||||||
|
|
||||||
c = state->hash_counter[hash];
|
|
||||||
|
|
||||||
offset2 = state->hash[hash].offset[0];
|
|
||||||
if(offset2 < src - MINOFFSET && c > 0 && ((fast_read(offset2, 3) ^ fetch) & 0xffffff) == 0)
|
|
||||||
{
|
|
||||||
matchlen = 3;
|
|
||||||
if(*(offset2 + matchlen) == *(src + matchlen))
|
|
||||||
{
|
|
||||||
matchlen = 4;
|
|
||||||
while(*(offset2 + matchlen) == *(src + matchlen) && matchlen < remaining)
|
|
||||||
matchlen++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else
|
|
||||||
matchlen = 0;
|
|
||||||
for(k = 1; k < QLZ_POINTERS && c > k; k++)
|
|
||||||
{
|
|
||||||
o = state->hash[hash].offset[k];
|
|
||||||
#if QLZ_COMPRESSION_LEVEL == 3
|
|
||||||
if(((fast_read(o, 3) ^ fetch) & 0xffffff) == 0 && o < src - MINOFFSET)
|
|
||||||
#elif QLZ_COMPRESSION_LEVEL == 2
|
|
||||||
if(*(src + matchlen) == *(o + matchlen) && ((fast_read(o, 3) ^ fetch) & 0xffffff) == 0 && o < src - MINOFFSET)
|
|
||||||
#endif
|
|
||||||
{
|
|
||||||
m = 3;
|
|
||||||
while(*(o + m) == *(src + m) && m < remaining)
|
|
||||||
m++;
|
|
||||||
#if QLZ_COMPRESSION_LEVEL == 3
|
|
||||||
if ((m > matchlen) || (m == matchlen && o > offset2))
|
|
||||||
#elif QLZ_COMPRESSION_LEVEL == 2
|
|
||||||
if (m > matchlen)
|
|
||||||
#endif
|
|
||||||
{
|
|
||||||
offset2 = o;
|
|
||||||
matchlen = m;
|
|
||||||
best_k = k;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
o = offset2;
|
|
||||||
state->hash[hash].offset[c & (QLZ_POINTERS - 1)] = src;
|
|
||||||
c++;
|
|
||||||
state->hash_counter[hash] = c;
|
|
||||||
|
|
||||||
#if QLZ_COMPRESSION_LEVEL == 3
|
|
||||||
if(matchlen > 2 && src - o < 131071)
|
|
||||||
{
|
|
||||||
ui32 u;
|
|
||||||
size_t offset = src - o;
|
|
||||||
|
|
||||||
for(u = 1; u < matchlen; u++)
|
|
||||||
{
|
|
||||||
hash = hashat(src + u);
|
|
||||||
c = state->hash_counter[hash]++;
|
|
||||||
state->hash[hash].offset[c & (QLZ_POINTERS - 1)] = src + u;
|
|
||||||
}
|
|
||||||
|
|
||||||
cword_val = (cword_val >> 1) | (1U << 31);
|
|
||||||
src += matchlen;
|
|
||||||
|
|
||||||
if(matchlen == 3 && offset <= 63)
|
|
||||||
{
|
|
||||||
*dst = (unsigned char)(offset << 2);
|
|
||||||
dst++;
|
|
||||||
}
|
|
||||||
else if (matchlen == 3 && offset <= 16383)
|
|
||||||
{
|
|
||||||
ui32 f = (ui32)((offset << 2) | 1);
|
|
||||||
fast_write(f, dst, 2);
|
|
||||||
dst += 2;
|
|
||||||
}
|
|
||||||
else if (matchlen <= 18 && offset <= 1023)
|
|
||||||
{
|
|
||||||
ui32 f = ((matchlen - 3) << 2) | ((ui32)offset << 6) | 2;
|
|
||||||
fast_write(f, dst, 2);
|
|
||||||
dst += 2;
|
|
||||||
}
|
|
||||||
|
|
||||||
else if(matchlen <= 33)
|
|
||||||
{
|
|
||||||
ui32 f = ((matchlen - 2) << 2) | ((ui32)offset << 7) | 3;
|
|
||||||
fast_write(f, dst, 3);
|
|
||||||
dst += 3;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
ui32 f = ((matchlen - 3) << 7) | ((ui32)offset << 15) | 3;
|
|
||||||
fast_write(f, dst, 4);
|
|
||||||
dst += 4;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
*dst = *src;
|
|
||||||
src++;
|
|
||||||
dst++;
|
|
||||||
cword_val = (cword_val >> 1);
|
|
||||||
}
|
|
||||||
#elif QLZ_COMPRESSION_LEVEL == 2
|
|
||||||
|
|
||||||
if(matchlen > 2)
|
|
||||||
{
|
|
||||||
cword_val = (cword_val >> 1) | (1U << 31);
|
|
||||||
src += matchlen;
|
|
||||||
|
|
||||||
if (matchlen < 10)
|
|
||||||
{
|
|
||||||
ui32 f = best_k | ((matchlen - 2) << 2) | (hash << 5);
|
|
||||||
fast_write(f, dst, 2);
|
|
||||||
dst += 2;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
ui32 f = best_k | (matchlen << 16) | (hash << 5);
|
|
||||||
fast_write(f, dst, 3);
|
|
||||||
dst += 3;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
*dst = *src;
|
|
||||||
src++;
|
|
||||||
dst++;
|
|
||||||
cword_val = (cword_val >> 1);
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
while (src <= last_byte)
|
|
||||||
{
|
|
||||||
if ((cword_val & 1) == 1)
|
|
||||||
{
|
|
||||||
fast_write((cword_val >> 1) | (1U << 31), cword_ptr, CWORD_LEN);
|
|
||||||
cword_ptr = dst;
|
|
||||||
dst += CWORD_LEN;
|
|
||||||
cword_val = 1U << 31;
|
|
||||||
}
|
|
||||||
#if QLZ_COMPRESSION_LEVEL < 3
|
|
||||||
if (src <= last_byte - 3)
|
|
||||||
{
|
|
||||||
#if QLZ_COMPRESSION_LEVEL == 1
|
|
||||||
ui32 hash, fetch;
|
|
||||||
fetch = fast_read(src, 3);
|
|
||||||
hash = hash_func(fetch);
|
|
||||||
state->hash[hash].offset = CAST(src - OFFSET_BASE);
|
|
||||||
state->hash[hash].cache = fetch;
|
|
||||||
#elif QLZ_COMPRESSION_LEVEL == 2
|
|
||||||
ui32 hash;
|
|
||||||
unsigned char c;
|
|
||||||
hash = hashat(src);
|
|
||||||
c = state->hash_counter[hash];
|
|
||||||
state->hash[hash].offset[c & (QLZ_POINTERS - 1)] = src;
|
|
||||||
c++;
|
|
||||||
state->hash_counter[hash] = c;
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
*dst = *src;
|
|
||||||
src++;
|
|
||||||
dst++;
|
|
||||||
cword_val = (cword_val >> 1);
|
|
||||||
}
|
|
||||||
|
|
||||||
while((cword_val & 1) != 1)
|
|
||||||
cword_val = (cword_val >> 1);
|
|
||||||
|
|
||||||
fast_write((cword_val >> 1) | (1U << 31), cword_ptr, CWORD_LEN);
|
|
||||||
|
|
||||||
// min. size must be 9 bytes so that the qlz_size functions can take 9 bytes as argument
|
|
||||||
return dst - destination < 9 ? 9 : dst - destination;
|
|
||||||
}
|
|
||||||
|
|
||||||
static size_t qlz_decompress_core(const unsigned char *source, unsigned char *destination, size_t size, qlz_state_decompress *state, const unsigned char *history)
|
|
||||||
{
|
|
||||||
const unsigned char *src = source + qlz_size_header((const char *)source);
|
|
||||||
unsigned char *dst = destination;
|
|
||||||
const unsigned char *last_destination_byte = destination + size - 1;
|
|
||||||
ui32 cword_val = 1;
|
|
||||||
const unsigned char *last_matchstart = last_destination_byte - UNCONDITIONAL_MATCHLEN - UNCOMPRESSED_END;
|
|
||||||
unsigned char *last_hashed = destination - 1;
|
|
||||||
const unsigned char *last_source_byte = source + qlz_size_compressed((const char *)source) - 1;
|
|
||||||
static const ui32 bitlut[16] = {4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0};
|
|
||||||
|
|
||||||
(void) last_source_byte;
|
|
||||||
(void) last_hashed;
|
|
||||||
(void) state;
|
|
||||||
(void) history;
|
|
||||||
|
|
||||||
for(;;)
|
|
||||||
{
|
|
||||||
ui32 fetch;
|
|
||||||
|
|
||||||
if (cword_val == 1)
|
|
||||||
{
|
|
||||||
#ifdef QLZ_MEMORY_SAFE
|
|
||||||
if(src + CWORD_LEN - 1 > last_source_byte)
|
|
||||||
return 0;
|
|
||||||
#endif
|
|
||||||
cword_val = fast_read(src, CWORD_LEN);
|
|
||||||
src += CWORD_LEN;
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef QLZ_MEMORY_SAFE
|
|
||||||
if(src + 4 - 1 > last_source_byte)
|
|
||||||
return 0;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
fetch = fast_read(src, 4);
|
|
||||||
|
|
||||||
if ((cword_val & 1) == 1)
|
|
||||||
{
|
|
||||||
ui32 matchlen;
|
|
||||||
const unsigned char *offset2;
|
|
||||||
|
|
||||||
#if QLZ_COMPRESSION_LEVEL == 1
|
|
||||||
ui32 hash;
|
|
||||||
cword_val = cword_val >> 1;
|
|
||||||
hash = (fetch >> 4) & 0xfff;
|
|
||||||
offset2 = (const unsigned char *)(size_t)state->hash[hash].offset;
|
|
||||||
|
|
||||||
if((fetch & 0xf) != 0)
|
|
||||||
{
|
|
||||||
matchlen = (fetch & 0xf) + 2;
|
|
||||||
src += 2;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
matchlen = *(src + 2);
|
|
||||||
src += 3;
|
|
||||||
}
|
|
||||||
|
|
||||||
#elif QLZ_COMPRESSION_LEVEL == 2
|
|
||||||
ui32 hash;
|
|
||||||
unsigned char c;
|
|
||||||
cword_val = cword_val >> 1;
|
|
||||||
hash = (fetch >> 5) & 0x7ff;
|
|
||||||
c = (unsigned char)(fetch & 0x3);
|
|
||||||
offset2 = state->hash[hash].offset[c];
|
|
||||||
|
|
||||||
if((fetch & (28)) != 0)
|
|
||||||
{
|
|
||||||
matchlen = ((fetch >> 2) & 0x7) + 2;
|
|
||||||
src += 2;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
matchlen = *(src + 2);
|
|
||||||
src += 3;
|
|
||||||
}
|
|
||||||
|
|
||||||
#elif QLZ_COMPRESSION_LEVEL == 3
|
|
||||||
ui32 offset;
|
|
||||||
cword_val = cword_val >> 1;
|
|
||||||
if ((fetch & 3) == 0)
|
|
||||||
{
|
|
||||||
offset = (fetch & 0xff) >> 2;
|
|
||||||
matchlen = 3;
|
|
||||||
src++;
|
|
||||||
}
|
|
||||||
else if ((fetch & 2) == 0)
|
|
||||||
{
|
|
||||||
offset = (fetch & 0xffff) >> 2;
|
|
||||||
matchlen = 3;
|
|
||||||
src += 2;
|
|
||||||
}
|
|
||||||
else if ((fetch & 1) == 0)
|
|
||||||
{
|
|
||||||
offset = (fetch & 0xffff) >> 6;
|
|
||||||
matchlen = ((fetch >> 2) & 15) + 3;
|
|
||||||
src += 2;
|
|
||||||
}
|
|
||||||
else if ((fetch & 127) != 3)
|
|
||||||
{
|
|
||||||
offset = (fetch >> 7) & 0x1ffff;
|
|
||||||
matchlen = ((fetch >> 2) & 0x1f) + 2;
|
|
||||||
src += 3;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
offset = (fetch >> 15);
|
|
||||||
matchlen = ((fetch >> 7) & 255) + 3;
|
|
||||||
src += 4;
|
|
||||||
}
|
|
||||||
|
|
||||||
offset2 = dst - offset;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifdef QLZ_MEMORY_SAFE
|
|
||||||
if(offset2 < history || offset2 > dst - MINOFFSET - 1)
|
|
||||||
return 0;
|
|
||||||
|
|
||||||
if(matchlen > (ui32)(last_destination_byte - dst - UNCOMPRESSED_END + 1))
|
|
||||||
return 0;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
memcpy_up(dst, offset2, matchlen);
|
|
||||||
dst += matchlen;
|
|
||||||
|
|
||||||
#if QLZ_COMPRESSION_LEVEL <= 2
|
|
||||||
update_hash_upto(state, &last_hashed, dst - matchlen);
|
|
||||||
last_hashed = dst - 1;
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
if (dst < last_matchstart)
|
|
||||||
{
|
|
||||||
unsigned int n = bitlut[cword_val & 0xf];
|
|
||||||
#ifdef X86X64
|
|
||||||
*(ui32 *)dst = *(ui32 *)src;
|
|
||||||
#else
|
|
||||||
memcpy_up(dst, src, 4);
|
|
||||||
#endif
|
|
||||||
cword_val = cword_val >> n;
|
|
||||||
dst += n;
|
|
||||||
src += n;
|
|
||||||
#if QLZ_COMPRESSION_LEVEL <= 2
|
|
||||||
update_hash_upto(state, &last_hashed, dst - 3);
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
while(dst <= last_destination_byte)
|
|
||||||
{
|
|
||||||
if (cword_val == 1)
|
|
||||||
{
|
|
||||||
src += CWORD_LEN;
|
|
||||||
cword_val = 1U << 31;
|
|
||||||
}
|
|
||||||
#ifdef QLZ_MEMORY_SAFE
|
|
||||||
if(src >= last_source_byte + 1)
|
|
||||||
return 0;
|
|
||||||
#endif
|
|
||||||
*dst = *src;
|
|
||||||
dst++;
|
|
||||||
src++;
|
|
||||||
cword_val = cword_val >> 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
#if QLZ_COMPRESSION_LEVEL <= 2
|
|
||||||
update_hash_upto(state, &last_hashed, last_destination_byte - 3); // todo, use constant
|
|
||||||
#endif
|
|
||||||
return size;
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
size_t qlz_compress(const void *source, char *destination, size_t size, qlz_state_compress *state)
|
|
||||||
{
|
|
||||||
size_t r;
|
|
||||||
ui32 compressed;
|
|
||||||
size_t base;
|
|
||||||
|
|
||||||
if(size == 0 || size > 0xffffffff - 400)
|
|
||||||
return 0;
|
|
||||||
|
|
||||||
if(size < 216)
|
|
||||||
base = 3;
|
|
||||||
else
|
|
||||||
base = 9;
|
|
||||||
|
|
||||||
#if QLZ_STREAMING_BUFFER > 0
|
|
||||||
if (state->stream_counter + size - 1 >= QLZ_STREAMING_BUFFER)
|
|
||||||
#endif
|
|
||||||
{
|
|
||||||
reset_table_compress(state);
|
|
||||||
r = base + qlz_compress_core((const unsigned char *)source, (unsigned char*)destination + base, size, state);
|
|
||||||
#if QLZ_STREAMING_BUFFER > 0
|
|
||||||
reset_table_compress(state);
|
|
||||||
#endif
|
|
||||||
if(r == base)
|
|
||||||
{
|
|
||||||
memcpy(destination + base, source, size);
|
|
||||||
r = size + base;
|
|
||||||
compressed = 0;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
compressed = 1;
|
|
||||||
}
|
|
||||||
state->stream_counter = 0;
|
|
||||||
}
|
|
||||||
#if QLZ_STREAMING_BUFFER > 0
|
|
||||||
else
|
|
||||||
{
|
|
||||||
unsigned char *src = state->stream_buffer + state->stream_counter;
|
|
||||||
|
|
||||||
memcpy(src, source, size);
|
|
||||||
r = base + qlz_compress_core(src, (unsigned char*)destination + base, size, state);
|
|
||||||
|
|
||||||
if(r == base)
|
|
||||||
{
|
|
||||||
memcpy(destination + base, src, size);
|
|
||||||
r = size + base;
|
|
||||||
compressed = 0;
|
|
||||||
reset_table_compress(state);
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
compressed = 1;
|
|
||||||
}
|
|
||||||
state->stream_counter += size;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
if(base == 3)
|
|
||||||
{
|
|
||||||
*destination = (unsigned char)(0 | compressed);
|
|
||||||
*(destination + 1) = (unsigned char)r;
|
|
||||||
*(destination + 2) = (unsigned char)size;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
*destination = (unsigned char)(2 | compressed);
|
|
||||||
fast_write((ui32)r, destination + 1, 4);
|
|
||||||
fast_write((ui32)size, destination + 5, 4);
|
|
||||||
}
|
|
||||||
|
|
||||||
*destination |= (QLZ_COMPRESSION_LEVEL << 2);
|
|
||||||
*destination |= (1 << 6);
|
|
||||||
*destination |= ((QLZ_STREAMING_BUFFER == 0 ? 0 : (QLZ_STREAMING_BUFFER == 100000 ? 1 : (QLZ_STREAMING_BUFFER == 1000000 ? 2 : 3))) << 4);
|
|
||||||
|
|
||||||
// 76543210
|
|
||||||
// 01SSLLHC
|
|
||||||
|
|
||||||
return r;
|
|
||||||
}
|
|
||||||
|
|
||||||
size_t qlz_decompress(const char *source, void *destination, qlz_state_decompress *state)
|
|
||||||
{
|
|
||||||
size_t dsiz = qlz_size_decompressed(source);
|
|
||||||
|
|
||||||
#if QLZ_STREAMING_BUFFER > 0
|
|
||||||
if (state->stream_counter + qlz_size_decompressed(source) - 1 >= QLZ_STREAMING_BUFFER)
|
|
||||||
#endif
|
|
||||||
{
|
|
||||||
if((*source & 1) == 1)
|
|
||||||
{
|
|
||||||
reset_table_decompress(state);
|
|
||||||
dsiz = qlz_decompress_core((const unsigned char *)source, (unsigned char *)destination, dsiz, state, (const unsigned char *)destination);
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
memcpy(destination, source + qlz_size_header(source), dsiz);
|
|
||||||
}
|
|
||||||
state->stream_counter = 0;
|
|
||||||
reset_table_decompress(state);
|
|
||||||
}
|
|
||||||
#if QLZ_STREAMING_BUFFER > 0
|
|
||||||
else
|
|
||||||
{
|
|
||||||
unsigned char *dst = state->stream_buffer + state->stream_counter;
|
|
||||||
if((*source & 1) == 1)
|
|
||||||
{
|
|
||||||
dsiz = qlz_decompress_core((const unsigned char *)source, dst, dsiz, state, (const unsigned char *)state->stream_buffer);
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
memcpy(dst, source + qlz_size_header(source), dsiz);
|
|
||||||
reset_table_decompress(state);
|
|
||||||
}
|
|
||||||
memcpy(destination, dst, dsiz);
|
|
||||||
state->stream_counter += dsiz;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
return dsiz;
|
|
||||||
}
|
|
||||||
|
|
||||||
@ -1,151 +0,0 @@
|
|||||||
#ifndef QLZ_HEADER
|
|
||||||
#define QLZ_HEADER
|
|
||||||
|
|
||||||
// Fast data compression library
|
|
||||||
// Copyright (C) 2006-2011 Lasse Mikkel Reinhold
|
|
||||||
// lar@quicklz.com
|
|
||||||
//
|
|
||||||
// QuickLZ can be used for free under the GPL 1, 2 or 3 license (where anything
|
|
||||||
// released into public must be open source) or under a commercial license if such
|
|
||||||
// has been acquired (see http://www.quicklz.com/order.html). The commercial license
|
|
||||||
// does not cover derived or ported versions created by third parties under GPL.
|
|
||||||
|
|
||||||
// You can edit following user settings. Data must be decompressed with the same
|
|
||||||
// setting of QLZ_COMPRESSION_LEVEL and QLZ_STREAMING_BUFFER as it was compressed
|
|
||||||
// (see manual). If QLZ_STREAMING_BUFFER > 0, scratch buffers must be initially
|
|
||||||
// zeroed out (see manual). First #ifndef makes it possible to define settings from
|
|
||||||
// the outside like the compiler command line.
|
|
||||||
|
|
||||||
// 1.5.0 final
|
|
||||||
|
|
||||||
#ifndef QLZ_COMPRESSION_LEVEL
|
|
||||||
|
|
||||||
// 1 gives fastest compression speed. 3 gives fastest decompression speed and best
|
|
||||||
// compression ratio.
|
|
||||||
//#define QLZ_COMPRESSION_LEVEL 1
|
|
||||||
//#define QLZ_COMPRESSION_LEVEL 2
|
|
||||||
#define QLZ_COMPRESSION_LEVEL 3
|
|
||||||
|
|
||||||
// If > 0, zero out both states prior to first call to qlz_compress() or qlz_decompress()
|
|
||||||
// and decompress packets in the same order as they were compressed
|
|
||||||
#define QLZ_STREAMING_BUFFER 0
|
|
||||||
//#define QLZ_STREAMING_BUFFER 1000
|
|
||||||
//#define QLZ_STREAMING_BUFFER 100000
|
|
||||||
//#define QLZ_STREAMING_BUFFER 1000000
|
|
||||||
|
|
||||||
// Guarantees that decompression of corrupted data cannot crash. Decreases decompression
|
|
||||||
// speed 10-20%. Compression speed not affected.
|
|
||||||
//#define QLZ_MEMORY_SAFE
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#define QLZ_VERSION_MAJOR 1
|
|
||||||
#define QLZ_VERSION_MINOR 5
|
|
||||||
#define QLZ_VERSION_REVISION 0
|
|
||||||
|
|
||||||
// Using size_t, memset() and memcpy()
|
|
||||||
#include <string.h>
|
|
||||||
|
|
||||||
// Verify compression level
|
|
||||||
#if QLZ_COMPRESSION_LEVEL != 1 && QLZ_COMPRESSION_LEVEL != 2 && QLZ_COMPRESSION_LEVEL != 3
|
|
||||||
#error QLZ_COMPRESSION_LEVEL must be 1, 2 or 3
|
|
||||||
#endif
|
|
||||||
|
|
||||||
typedef unsigned int ui32;
|
|
||||||
typedef unsigned short int ui16;
|
|
||||||
|
|
||||||
// Decrease QLZ_POINTERS for level 3 to increase compression speed. Do not touch any other values!
|
|
||||||
#if QLZ_COMPRESSION_LEVEL == 1
|
|
||||||
#define QLZ_POINTERS 1
|
|
||||||
#define QLZ_HASH_VALUES 4096
|
|
||||||
#elif QLZ_COMPRESSION_LEVEL == 2
|
|
||||||
#define QLZ_POINTERS 4
|
|
||||||
#define QLZ_HASH_VALUES 2048
|
|
||||||
#elif QLZ_COMPRESSION_LEVEL == 3
|
|
||||||
#define QLZ_POINTERS 16
|
|
||||||
#define QLZ_HASH_VALUES 4096
|
|
||||||
#endif
|
|
||||||
|
|
||||||
// Detect if pointer size is 64-bit. It's not fatal if some 64-bit target is not detected because this is only for adding an optional 64-bit optimization.
|
|
||||||
#if defined _LP64 || defined __LP64__ || defined __64BIT__ || _ADDR64 || defined _WIN64 || defined __arch64__ || __WORDSIZE == 64 || (defined __sparc && defined __sparcv9) || defined __x86_64 || defined __amd64 || defined __x86_64__ || defined _M_X64 || defined _M_IA64 || defined __ia64 || defined __IA64__
|
|
||||||
#define QLZ_PTR_64
|
|
||||||
#endif
|
|
||||||
|
|
||||||
// hash entry
|
|
||||||
typedef struct
|
|
||||||
{
|
|
||||||
#if QLZ_COMPRESSION_LEVEL == 1
|
|
||||||
ui32 cache;
|
|
||||||
#if defined QLZ_PTR_64 && QLZ_STREAMING_BUFFER == 0
|
|
||||||
unsigned int offset;
|
|
||||||
#else
|
|
||||||
const unsigned char *offset;
|
|
||||||
#endif
|
|
||||||
#else
|
|
||||||
const unsigned char *offset[QLZ_POINTERS];
|
|
||||||
#endif
|
|
||||||
|
|
||||||
} qlz_hash_compress;
|
|
||||||
|
|
||||||
typedef struct
|
|
||||||
{
|
|
||||||
#if QLZ_COMPRESSION_LEVEL == 1
|
|
||||||
const unsigned char *offset;
|
|
||||||
#else
|
|
||||||
const unsigned char *offset[QLZ_POINTERS];
|
|
||||||
#endif
|
|
||||||
} qlz_hash_decompress;
|
|
||||||
|
|
||||||
|
|
||||||
// states
|
|
||||||
typedef struct
|
|
||||||
{
|
|
||||||
#if QLZ_STREAMING_BUFFER > 0
|
|
||||||
unsigned char stream_buffer[QLZ_STREAMING_BUFFER];
|
|
||||||
#endif
|
|
||||||
size_t stream_counter;
|
|
||||||
qlz_hash_compress hash[QLZ_HASH_VALUES];
|
|
||||||
unsigned char hash_counter[QLZ_HASH_VALUES];
|
|
||||||
} qlz_state_compress;
|
|
||||||
|
|
||||||
|
|
||||||
#if QLZ_COMPRESSION_LEVEL == 1 || QLZ_COMPRESSION_LEVEL == 2
|
|
||||||
typedef struct
|
|
||||||
{
|
|
||||||
#if QLZ_STREAMING_BUFFER > 0
|
|
||||||
unsigned char stream_buffer[QLZ_STREAMING_BUFFER];
|
|
||||||
#endif
|
|
||||||
qlz_hash_decompress hash[QLZ_HASH_VALUES];
|
|
||||||
unsigned char hash_counter[QLZ_HASH_VALUES];
|
|
||||||
size_t stream_counter;
|
|
||||||
} qlz_state_decompress;
|
|
||||||
#elif QLZ_COMPRESSION_LEVEL == 3
|
|
||||||
typedef struct
|
|
||||||
{
|
|
||||||
#if QLZ_STREAMING_BUFFER > 0
|
|
||||||
unsigned char stream_buffer[QLZ_STREAMING_BUFFER];
|
|
||||||
#endif
|
|
||||||
#if QLZ_COMPRESSION_LEVEL <= 2
|
|
||||||
qlz_hash_decompress hash[QLZ_HASH_VALUES];
|
|
||||||
#endif
|
|
||||||
size_t stream_counter;
|
|
||||||
} qlz_state_decompress;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
#if defined (__cplusplus)
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
// Public functions of QuickLZ
|
|
||||||
size_t qlz_size_decompressed(const char *source);
|
|
||||||
size_t qlz_size_compressed(const char *source);
|
|
||||||
size_t qlz_compress(const void *source, char *destination, size_t size, qlz_state_compress *state);
|
|
||||||
size_t qlz_decompress(const char *source, void *destination, qlz_state_decompress *state);
|
|
||||||
int qlz_get_setting(int setting);
|
|
||||||
|
|
||||||
#if defined (__cplusplus)
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
62
arm9/source/system/pcx.c
Normal file
62
arm9/source/system/pcx.c
Normal file
@ -0,0 +1,62 @@
|
|||||||
|
#include <stddef.h>
|
||||||
|
#include <stdint.h>
|
||||||
|
|
||||||
|
#include "pcx.h"
|
||||||
|
|
||||||
|
// Define __PCX_INVERT_RGB to have the buffer output in BGR24
|
||||||
|
#define __PCX_INVERT_RGB
|
||||||
|
|
||||||
|
|
||||||
|
static inline int PCX_Validate(const PCXHdr *hdr) {
|
||||||
|
return (hdr != NULL &&
|
||||||
|
hdr->manufacturer == 10 &&
|
||||||
|
PCX_Encoding(hdr) == 1 &&
|
||||||
|
PCX_PlaneCount(hdr) == 1 &&
|
||||||
|
PCX_BitsPerPixel(hdr) == 8) ? 1 : 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
int PCX_Decompress(u8 *out_buf, size_t out_maxlen, const u8 *pcx_data, size_t pcx_len) {
|
||||||
|
const PCXHdr *pcx = (const PCXHdr*)pcx_data;
|
||||||
|
const u8 *pcx_palette, *out_start, *out_end, *pcx_bitmap, *pcx_end;
|
||||||
|
int mrk, palind;
|
||||||
|
|
||||||
|
if (PCX_Validate(pcx) == 0 || (size_t) (PCX_BitmapSize(pcx) * 3) > out_maxlen)
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
pcx_end = pcx_data + pcx_len - 769;
|
||||||
|
out_end = out_buf + out_maxlen;
|
||||||
|
out_start = out_buf;
|
||||||
|
pcx_bitmap = PCX_Bitmap(pcx);
|
||||||
|
pcx_palette = PCX_Palette(pcx, pcx_len);
|
||||||
|
|
||||||
|
while (pcx_bitmap < pcx_end && out_buf < out_end) {
|
||||||
|
mrk = *(pcx_bitmap++);
|
||||||
|
|
||||||
|
if (mrk >= 0xC0) {
|
||||||
|
mrk -= 0xC0;
|
||||||
|
palind = *(pcx_bitmap++) * 3;
|
||||||
|
|
||||||
|
if ((out_buf + mrk) > out_end) {
|
||||||
|
// TODO: report the buffer overflow somehow
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
palind = mrk * 3;
|
||||||
|
mrk = 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
while (mrk--) {
|
||||||
|
#ifdef __PCX_INVERT_RGB
|
||||||
|
*(out_buf++) = pcx_palette[palind + 2];
|
||||||
|
*(out_buf++) = pcx_palette[palind + 1];
|
||||||
|
*(out_buf++) = pcx_palette[palind + 0];
|
||||||
|
#else
|
||||||
|
*(out_buf++) = pcx_palette[palind + 0];
|
||||||
|
*(out_buf++) = pcx_palette[palind + 1];
|
||||||
|
*(out_buf++) = pcx_palette[palind + 2];
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return (out_buf - out_start);
|
||||||
|
}
|
||||||
35
arm9/source/system/pcx.h
Normal file
35
arm9/source/system/pcx.h
Normal file
@ -0,0 +1,35 @@
|
|||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include <stdint.h>
|
||||||
|
#include "common.h"
|
||||||
|
|
||||||
|
typedef struct {
|
||||||
|
u8 manufacturer;
|
||||||
|
u8 version;
|
||||||
|
u8 enc;
|
||||||
|
u8 bpp;
|
||||||
|
u16 minx;
|
||||||
|
u16 miny;
|
||||||
|
u16 maxx;
|
||||||
|
u16 maxy;
|
||||||
|
u16 hres;
|
||||||
|
u16 vres;
|
||||||
|
u8 egapalette[48];
|
||||||
|
u8 reserved;
|
||||||
|
u8 clrplanes;
|
||||||
|
u16 bytesperline;
|
||||||
|
u16 palettetype;
|
||||||
|
u8 resv_[58];
|
||||||
|
} __attribute__((packed)) PCXHdr;
|
||||||
|
|
||||||
|
#define PCX_Width(hdr) (hdr->maxx - hdr->minx + 1)
|
||||||
|
#define PCX_Height(hdr) (hdr->maxy - hdr->miny + 1)
|
||||||
|
#define PCX_BitsPerPixel(hdr) (hdr->bpp)
|
||||||
|
#define PCX_BitmapSize(hdr) (PCX_Width(hdr) * PCX_Height(hdr))
|
||||||
|
#define PCX_MaxColors(hdr) (1<<PCX_BitsPerPixel(hdr))
|
||||||
|
#define PCX_PlaneCount(hdr) (hdr->clrplanes)
|
||||||
|
#define PCX_Encoding(hdr) (hdr->enc)
|
||||||
|
#define PCX_Palette(hdr, pcx_len) (((u8*)hdr) + pcx_len - 768)
|
||||||
|
#define PCX_Bitmap(hdr) (((u8*)hdr) + sizeof(PCXHdr))
|
||||||
|
|
||||||
|
int PCX_Decompress(u8 *out_buf, size_t out_maxlen, const u8 *pcx_data, size_t pcx_len);
|
||||||
@ -7,7 +7,7 @@
|
|||||||
// known file names inside VRAM0 TAR
|
// known file names inside VRAM0 TAR
|
||||||
#define VRAM0_AUTORUN_GM9 "autorun.gm9"
|
#define VRAM0_AUTORUN_GM9 "autorun.gm9"
|
||||||
#define VRAM0_README_MD "README.md"
|
#define VRAM0_README_MD "README.md"
|
||||||
#define VRAM0_SPLASH_QLZ FLAVOR "_splash.qlz"
|
#define VRAM0_SPLASH_PCX FLAVOR "_splash.pcx"
|
||||||
|
|
||||||
|
|
||||||
#define VRAM0_OFFSET 0x18000000
|
#define VRAM0_OFFSET 0x18000000
|
||||||
|
|||||||
BIN
resources/GodMode9_splash.pcx
Normal file
BIN
resources/GodMode9_splash.pcx
Normal file
Binary file not shown.
Binary file not shown.
BIN
resources/SafeMode9_splash.pcx
Normal file
BIN
resources/SafeMode9_splash.pcx
Normal file
Binary file not shown.
Binary file not shown.
Loading…
x
Reference in New Issue
Block a user