Merge pull request #47890 from akien-mga/etcpak-compress-only
etcpak: We only need the compression code, remove rest of etcpak app
This commit is contained in:
Rémi Verschelde
GitHub
commit
b6a31d0bf6
|
|
@ -11,31 +11,15 @@ thirdparty_obj = []
|
|||
|
||||
thirdparty_dir = "#thirdparty/etcpak/"
|
||||
thirdparty_sources = [
|
||||
"Bitmap.cpp",
|
||||
"BitmapDownsampled.cpp",
|
||||
"BlockData.cpp",
|
||||
"ColorSpace.cpp",
|
||||
"DataProvider.cpp",
|
||||
"Debug.cpp",
|
||||
"Dither.cpp",
|
||||
"Error.cpp",
|
||||
"mmap.cpp",
|
||||
"ProcessDxtc.cpp",
|
||||
"ProcessRGB.cpp",
|
||||
"System.cpp",
|
||||
"Tables.cpp",
|
||||
"TaskDispatch.cpp",
|
||||
"Timing.cpp",
|
||||
"lz4/lz4.c",
|
||||
]
|
||||
thirdparty_sources = [thirdparty_dir + file for file in thirdparty_sources]
|
||||
|
||||
env_etcpak.Prepend(CPPPATH=[thirdparty_dir])
|
||||
|
||||
# Also requires libpng headers
|
||||
if env["builtin_libpng"]:
|
||||
env_etcpak.Prepend(CPPPATH=["#thirdparty/libpng"])
|
||||
|
||||
env_thirdparty = env_etcpak.Clone()
|
||||
env_thirdparty.disable_warnings()
|
||||
env_thirdparty.add_source_files(thirdparty_obj, thirdparty_sources)
|
||||
|
|
|
|||
|
|
@ -89,15 +89,16 @@ will limit its functionality to IPv4 only.
|
|||
## etcpak
|
||||
|
||||
- Upstream: https://github.com/wolfpld/etcpak
|
||||
- Version: git (403d38b3f1cb347c196d845d0a05e44a00d17169, 2021)
|
||||
- Version: git (f27daea656ff77671580f838a889e33049430ebd, 2021)
|
||||
- License: BSD-3-Clause
|
||||
|
||||
Important: Some Godot-made changes, see `patches` folders.
|
||||
|
||||
Files extracted from upstream source:
|
||||
|
||||
- All `.cpp` and `.hpp` files in the root folder except `Application.cpp`.
|
||||
- `lz4` folder.
|
||||
- Only the files relevant for compression (i.e. `Process*.cpp` and their deps):
|
||||
```
|
||||
Dither.{cpp,hpp} ForceInline.hpp Math.hpp ProcessCommon.hpp ProcessRGB.{cpp,hpp}
|
||||
ProcessDxtc.{cpp,hpp} Tables.{cpp,hpp} Vector.hpp
|
||||
```
|
||||
- `AUTHORS.txt` and `LICENSE.txt`
|
||||
|
||||
## fonts
|
||||
|
|
|
|||
|
|
@ -1,216 +0,0 @@
|
|||
#include <ctype.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <assert.h>
|
||||
|
||||
#include <png.h>
|
||||
#include "lz4/lz4.h"
|
||||
|
||||
#include "Bitmap.hpp"
|
||||
#include "Debug.hpp"
|
||||
|
||||
Bitmap::Bitmap( const char* fn, unsigned int lines, bool bgr )
|
||||
: m_block( nullptr )
|
||||
, m_lines( lines )
|
||||
, m_alpha( true )
|
||||
, m_sema( 0 )
|
||||
{
|
||||
FILE* f = fopen( fn, "rb" );
|
||||
assert( f );
|
||||
|
||||
char buf[4];
|
||||
fread( buf, 1, 4, f );
|
||||
if( memcmp( buf, "raw4", 4 ) == 0 )
|
||||
{
|
||||
uint8_t a;
|
||||
fread( &a, 1, 1, f );
|
||||
m_alpha = a == 1;
|
||||
uint32_t d;
|
||||
fread( &d, 1, 4, f );
|
||||
m_size.x = d;
|
||||
fread( &d, 1, 4, f );
|
||||
m_size.y = d;
|
||||
DBGPRINT( "Raw bitmap " << fn << " " << m_size.x << "x" << m_size.y );
|
||||
|
||||
assert( m_size.x % 4 == 0 );
|
||||
assert( m_size.y % 4 == 0 );
|
||||
|
||||
int32_t csize;
|
||||
fread( &csize, 1, 4, f );
|
||||
char* cbuf = new char[csize];
|
||||
fread( cbuf, 1, csize, f );
|
||||
fclose( f );
|
||||
|
||||
m_block = m_data = new uint32_t[m_size.x*m_size.y];
|
||||
m_linesLeft = m_size.y / 4;
|
||||
|
||||
LZ4_decompress_fast( cbuf, (char*)m_data, m_size.x*m_size.y*4 );
|
||||
delete[] cbuf;
|
||||
|
||||
for( int i=0; i<m_size.y/4; i++ )
|
||||
{
|
||||
m_sema.unlock();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
fseek( f, 0, SEEK_SET );
|
||||
|
||||
unsigned int sig_read = 0;
|
||||
int bit_depth, color_type, interlace_type;
|
||||
|
||||
png_structp png_ptr = png_create_read_struct( PNG_LIBPNG_VER_STRING, NULL, NULL, NULL );
|
||||
png_infop info_ptr = png_create_info_struct( png_ptr );
|
||||
setjmp( png_jmpbuf( png_ptr ) );
|
||||
|
||||
png_init_io( png_ptr, f );
|
||||
png_set_sig_bytes( png_ptr, sig_read );
|
||||
|
||||
png_uint_32 w, h;
|
||||
|
||||
png_read_info( png_ptr, info_ptr );
|
||||
png_get_IHDR( png_ptr, info_ptr, &w, &h, &bit_depth, &color_type, &interlace_type, NULL, NULL );
|
||||
|
||||
m_size = v2i( w, h );
|
||||
|
||||
png_set_strip_16( png_ptr );
|
||||
if( color_type == PNG_COLOR_TYPE_PALETTE )
|
||||
{
|
||||
png_set_palette_to_rgb( png_ptr );
|
||||
}
|
||||
else if( color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8 )
|
||||
{
|
||||
png_set_expand_gray_1_2_4_to_8( png_ptr );
|
||||
}
|
||||
if( png_get_valid( png_ptr, info_ptr, PNG_INFO_tRNS ) )
|
||||
{
|
||||
png_set_tRNS_to_alpha( png_ptr );
|
||||
}
|
||||
if( color_type == PNG_COLOR_TYPE_GRAY_ALPHA )
|
||||
{
|
||||
png_set_gray_to_rgb(png_ptr);
|
||||
}
|
||||
if( bgr )
|
||||
{
|
||||
png_set_bgr(png_ptr);
|
||||
}
|
||||
|
||||
switch( color_type )
|
||||
{
|
||||
case PNG_COLOR_TYPE_PALETTE:
|
||||
if( !png_get_valid( png_ptr, info_ptr, PNG_INFO_tRNS ) )
|
||||
{
|
||||
png_set_filler( png_ptr, 0xff, PNG_FILLER_AFTER );
|
||||
m_alpha = false;
|
||||
}
|
||||
break;
|
||||
case PNG_COLOR_TYPE_GRAY_ALPHA:
|
||||
png_set_gray_to_rgb( png_ptr );
|
||||
break;
|
||||
case PNG_COLOR_TYPE_RGB:
|
||||
png_set_filler( png_ptr, 0xff, PNG_FILLER_AFTER );
|
||||
m_alpha = false;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
DBGPRINT( "Bitmap " << fn << " " << w << "x" << h );
|
||||
|
||||
assert( w % 4 == 0 );
|
||||
assert( h % 4 == 0 );
|
||||
|
||||
m_block = m_data = new uint32_t[w*h];
|
||||
m_linesLeft = h / 4;
|
||||
|
||||
m_load = std::async( std::launch::async, [this, f, png_ptr, info_ptr]() mutable
|
||||
{
|
||||
auto ptr = m_data;
|
||||
unsigned int lines = 0;
|
||||
for( int i=0; i<m_size.y / 4; i++ )
|
||||
{
|
||||
for( int j=0; j<4; j++ )
|
||||
{
|
||||
png_read_rows( png_ptr, (png_bytepp)&ptr, NULL, 1 );
|
||||
ptr += m_size.x;
|
||||
}
|
||||
lines++;
|
||||
if( lines >= m_lines )
|
||||
{
|
||||
lines = 0;
|
||||
m_sema.unlock();
|
||||
}
|
||||
}
|
||||
|
||||
if( lines != 0 )
|
||||
{
|
||||
m_sema.unlock();
|
||||
}
|
||||
|
||||
png_read_end( png_ptr, info_ptr );
|
||||
png_destroy_read_struct( &png_ptr, &info_ptr, NULL );
|
||||
fclose( f );
|
||||
} );
|
||||
}
|
||||
}
|
||||
|
||||
Bitmap::Bitmap( const v2i& size )
|
||||
: m_data( new uint32_t[size.x*size.y] )
|
||||
, m_block( nullptr )
|
||||
, m_lines( 1 )
|
||||
, m_linesLeft( size.y / 4 )
|
||||
, m_size( size )
|
||||
, m_sema( 0 )
|
||||
{
|
||||
}
|
||||
|
||||
Bitmap::Bitmap( const Bitmap& src, unsigned int lines )
|
||||
: m_lines( lines )
|
||||
, m_alpha( src.Alpha() )
|
||||
, m_sema( 0 )
|
||||
{
|
||||
}
|
||||
|
||||
Bitmap::~Bitmap()
|
||||
{
|
||||
delete[] m_data;
|
||||
}
|
||||
|
||||
void Bitmap::Write( const char* fn )
|
||||
{
|
||||
FILE* f = fopen( fn, "wb" );
|
||||
assert( f );
|
||||
|
||||
png_structp png_ptr = png_create_write_struct( PNG_LIBPNG_VER_STRING, NULL, NULL, NULL );
|
||||
png_infop info_ptr = png_create_info_struct( png_ptr );
|
||||
setjmp( png_jmpbuf( png_ptr ) );
|
||||
png_init_io( png_ptr, f );
|
||||
|
||||
png_set_IHDR( png_ptr, info_ptr, m_size.x, m_size.y, 8, PNG_COLOR_TYPE_RGB_ALPHA, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE );
|
||||
|
||||
png_write_info( png_ptr, info_ptr );
|
||||
|
||||
uint32_t* ptr = m_data;
|
||||
for( int i=0; i<m_size.y; i++ )
|
||||
{
|
||||
png_write_rows( png_ptr, (png_bytepp)(&ptr), 1 );
|
||||
ptr += m_size.x;
|
||||
}
|
||||
|
||||
png_write_end( png_ptr, info_ptr );
|
||||
png_destroy_write_struct( &png_ptr, &info_ptr );
|
||||
|
||||
fclose( f );
|
||||
}
|
||||
|
||||
const uint32_t* Bitmap::NextBlock( unsigned int& lines, bool& done )
|
||||
{
|
||||
std::lock_guard<std::mutex> lock( m_lock );
|
||||
lines = std::min( m_lines, m_linesLeft );
|
||||
auto ret = m_block;
|
||||
m_sema.lock();
|
||||
m_block += m_size.x * 4 * lines;
|
||||
m_linesLeft -= lines;
|
||||
done = m_linesLeft == 0;
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -1,50 +0,0 @@
|
|||
#ifndef __DARKRL__BITMAP_HPP__
|
||||
#define __DARKRL__BITMAP_HPP__
|
||||
|
||||
#include <future>
|
||||
#include <memory>
|
||||
#include <mutex>
|
||||
#include <stdint.h>
|
||||
|
||||
#include "Semaphore.hpp"
|
||||
#include "Vector.hpp"
|
||||
|
||||
enum class Channels
|
||||
{
|
||||
RGB,
|
||||
Alpha
|
||||
};
|
||||
|
||||
class Bitmap
|
||||
{
|
||||
public:
|
||||
Bitmap( const char* fn, unsigned int lines, bool bgr );
|
||||
Bitmap( const v2i& size );
|
||||
virtual ~Bitmap();
|
||||
|
||||
void Write( const char* fn );
|
||||
|
||||
uint32_t* Data() { if( m_load.valid() ) m_load.wait(); return m_data; }
|
||||
const uint32_t* Data() const { if( m_load.valid() ) m_load.wait(); return m_data; }
|
||||
const v2i& Size() const { return m_size; }
|
||||
bool Alpha() const { return m_alpha; }
|
||||
|
||||
const uint32_t* NextBlock( unsigned int& lines, bool& done );
|
||||
|
||||
protected:
|
||||
Bitmap( const Bitmap& src, unsigned int lines );
|
||||
|
||||
uint32_t* m_data;
|
||||
uint32_t* m_block;
|
||||
unsigned int m_lines;
|
||||
unsigned int m_linesLeft;
|
||||
v2i m_size;
|
||||
bool m_alpha;
|
||||
Semaphore m_sema;
|
||||
std::mutex m_lock;
|
||||
std::future<void> m_load;
|
||||
};
|
||||
|
||||
typedef std::shared_ptr<Bitmap> BitmapPtr;
|
||||
|
||||
#endif
|
||||
|
|
@ -1,86 +0,0 @@
|
|||
#include <string.h>
|
||||
#include <utility>
|
||||
|
||||
#include "BitmapDownsampled.hpp"
|
||||
#include "Debug.hpp"
|
||||
|
||||
BitmapDownsampled::BitmapDownsampled( const Bitmap& bmp, unsigned int lines )
|
||||
: Bitmap( bmp, lines )
|
||||
{
|
||||
m_size.x = std::max( 1, bmp.Size().x / 2 );
|
||||
m_size.y = std::max( 1, bmp.Size().y / 2 );
|
||||
|
||||
int w = std::max( m_size.x, 4 );
|
||||
int h = std::max( m_size.y, 4 );
|
||||
|
||||
DBGPRINT( "Subbitmap " << m_size.x << "x" << m_size.y );
|
||||
|
||||
m_block = m_data = new uint32_t[w*h];
|
||||
|
||||
if( m_size.x < w || m_size.y < h )
|
||||
{
|
||||
memset( m_data, 0, w*h*sizeof( uint32_t ) );
|
||||
m_linesLeft = h / 4;
|
||||
unsigned int lines = 0;
|
||||
for( int i=0; i<h/4; i++ )
|
||||
{
|
||||
for( int j=0; j<4; j++ )
|
||||
{
|
||||
lines++;
|
||||
if( lines > m_lines )
|
||||
{
|
||||
lines = 0;
|
||||
m_sema.unlock();
|
||||
}
|
||||
}
|
||||
}
|
||||
if( lines != 0 )
|
||||
{
|
||||
m_sema.unlock();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
m_linesLeft = h / 4;
|
||||
m_load = std::async( std::launch::async, [this, &bmp, w, h]() mutable
|
||||
{
|
||||
auto ptr = m_data;
|
||||
auto src1 = bmp.Data();
|
||||
auto src2 = src1 + bmp.Size().x;
|
||||
unsigned int lines = 0;
|
||||
for( int i=0; i<h/4; i++ )
|
||||
{
|
||||
for( int j=0; j<4; j++ )
|
||||
{
|
||||
for( int k=0; k<m_size.x; k++ )
|
||||
{
|
||||
int r = ( ( *src1 & 0x000000FF ) + ( *(src1+1) & 0x000000FF ) + ( *src2 & 0x000000FF ) + ( *(src2+1) & 0x000000FF ) ) / 4;
|
||||
int g = ( ( ( *src1 & 0x0000FF00 ) + ( *(src1+1) & 0x0000FF00 ) + ( *src2 & 0x0000FF00 ) + ( *(src2+1) & 0x0000FF00 ) ) / 4 ) & 0x0000FF00;
|
||||
int b = ( ( ( *src1 & 0x00FF0000 ) + ( *(src1+1) & 0x00FF0000 ) + ( *src2 & 0x00FF0000 ) + ( *(src2+1) & 0x00FF0000 ) ) / 4 ) & 0x00FF0000;
|
||||
int a = ( ( ( ( ( *src1 & 0xFF000000 ) >> 8 ) + ( ( *(src1+1) & 0xFF000000 ) >> 8 ) + ( ( *src2 & 0xFF000000 ) >> 8 ) + ( ( *(src2+1) & 0xFF000000 ) >> 8 ) ) / 4 ) & 0x00FF0000 ) << 8;
|
||||
*ptr++ = r | g | b | a;
|
||||
src1 += 2;
|
||||
src2 += 2;
|
||||
}
|
||||
src1 += m_size.x * 2;
|
||||
src2 += m_size.x * 2;
|
||||
}
|
||||
lines++;
|
||||
if( lines >= m_lines )
|
||||
{
|
||||
lines = 0;
|
||||
m_sema.unlock();
|
||||
}
|
||||
}
|
||||
|
||||
if( lines != 0 )
|
||||
{
|
||||
m_sema.unlock();
|
||||
}
|
||||
} );
|
||||
}
|
||||
}
|
||||
|
||||
BitmapDownsampled::~BitmapDownsampled()
|
||||
{
|
||||
}
|
||||
|
|
@ -1,13 +0,0 @@
|
|||
#ifndef __DARKRL__BITMAPDOWNSAMPLED_HPP__
|
||||
#define __DARKRL__BITMAPDOWNSAMPLED_HPP__
|
||||
|
||||
#include "Bitmap.hpp"
|
||||
|
||||
class BitmapDownsampled : public Bitmap
|
||||
{
|
||||
public:
|
||||
BitmapDownsampled( const Bitmap& bmp, unsigned int lines );
|
||||
~BitmapDownsampled();
|
||||
};
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -1,56 +0,0 @@
|
|||
#ifndef __BLOCKDATA_HPP__
|
||||
#define __BLOCKDATA_HPP__
|
||||
|
||||
#include <condition_variable>
|
||||
#include <future>
|
||||
#include <memory>
|
||||
#include <mutex>
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <vector>
|
||||
|
||||
#include "Bitmap.hpp"
|
||||
#include "ForceInline.hpp"
|
||||
#include "Vector.hpp"
|
||||
|
||||
class BlockData
|
||||
{
|
||||
public:
|
||||
enum Type
|
||||
{
|
||||
Etc1,
|
||||
Etc2_RGB,
|
||||
Etc2_RGBA,
|
||||
Dxt1,
|
||||
Dxt5
|
||||
};
|
||||
|
||||
BlockData( const char* fn );
|
||||
BlockData( const char* fn, const v2i& size, bool mipmap, Type type );
|
||||
BlockData( const v2i& size, bool mipmap, Type type );
|
||||
~BlockData();
|
||||
|
||||
BitmapPtr Decode();
|
||||
|
||||
void Process( const uint32_t* src, uint32_t blocks, size_t offset, size_t width, Channels type, bool dither );
|
||||
void ProcessRGBA( const uint32_t* src, uint32_t blocks, size_t offset, size_t width );
|
||||
|
||||
const v2i& Size() const { return m_size; }
|
||||
|
||||
private:
|
||||
etcpak_no_inline BitmapPtr DecodeRGB();
|
||||
etcpak_no_inline BitmapPtr DecodeRGBA();
|
||||
etcpak_no_inline BitmapPtr DecodeDxt1();
|
||||
etcpak_no_inline BitmapPtr DecodeDxt5();
|
||||
|
||||
uint8_t* m_data;
|
||||
v2i m_size;
|
||||
size_t m_dataOffset;
|
||||
FILE* m_file;
|
||||
size_t m_maplen;
|
||||
Type m_type;
|
||||
};
|
||||
|
||||
typedef std::shared_ptr<BlockData> BlockDataPtr;
|
||||
|
||||
#endif
|
||||
|
|
@ -1,114 +0,0 @@
|
|||
#include <math.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#include "Math.hpp"
|
||||
#include "ColorSpace.hpp"
|
||||
|
||||
namespace Color
|
||||
{
|
||||
|
||||
static const XYZ white( v3b( 255, 255, 255 ) );
|
||||
static const v3f rwhite( 1.f / white.x, 1.f / white.y, 1.f / white.z );
|
||||
|
||||
|
||||
XYZ::XYZ( float _x, float _y, float _z )
|
||||
: x( _x )
|
||||
, y( _y )
|
||||
, z( _z )
|
||||
{
|
||||
}
|
||||
|
||||
XYZ::XYZ( const v3b& rgb )
|
||||
{
|
||||
const float r = rgb.x / 255.f;
|
||||
const float g = rgb.y / 255.f;
|
||||
const float b = rgb.z / 255.f;
|
||||
|
||||
const float rl = sRGB2linear( r );
|
||||
const float gl = sRGB2linear( g );
|
||||
const float bl = sRGB2linear( b );
|
||||
|
||||
x = 0.4124f * rl + 0.3576f * gl + 0.1805f * bl;
|
||||
y = 0.2126f * rl + 0.7152f * gl + 0.0722f * bl;
|
||||
z = 0.0193f * rl + 0.1192f * gl + 0.9505f * bl;
|
||||
}
|
||||
|
||||
static float revlab( float t )
|
||||
{
|
||||
const float p1 = 6.f/29.f;
|
||||
const float p2 = 4.f/29.f;
|
||||
|
||||
if( t > p1 )
|
||||
{
|
||||
return t*t*t;
|
||||
}
|
||||
else
|
||||
{
|
||||
return 3 * sq( p1 ) * ( t - p2 );
|
||||
}
|
||||
}
|
||||
|
||||
XYZ::XYZ( const Lab& lab )
|
||||
{
|
||||
y = white.y * revlab( 1.f/116.f * ( lab.L + 16 ) );
|
||||
x = white.x * revlab( 1.f/116.f * ( lab.L + 16 ) + 1.f/500.f * lab.a );
|
||||
z = white.z * revlab( 1.f/116.f * ( lab.L + 16 ) - 1.f/200.f * lab.b );
|
||||
}
|
||||
|
||||
v3i XYZ::RGB() const
|
||||
{
|
||||
const float rl = 3.2406f * x - 1.5372f * y - 0.4986f * z;
|
||||
const float gl = -0.9689f * x + 1.8758f * y + 0.0415f * z;
|
||||
const float bl = 0.0557f * x - 0.2040f * y + 1.0570f * z;
|
||||
|
||||
const float r = linear2sRGB( rl );
|
||||
const float g = linear2sRGB( gl );
|
||||
const float b = linear2sRGB( bl );
|
||||
|
||||
return v3i( clampu8( int32_t( r * 255 ) ), clampu8( int32_t( g * 255 ) ), clampu8( int32_t( b * 255 ) ) );
|
||||
}
|
||||
|
||||
|
||||
Lab::Lab()
|
||||
: L( 0 )
|
||||
, a( 0 )
|
||||
, b( 0 )
|
||||
{
|
||||
}
|
||||
|
||||
Lab::Lab( float L, float a, float b )
|
||||
: L( L )
|
||||
, a( a )
|
||||
, b( b )
|
||||
{
|
||||
}
|
||||
|
||||
static float labfunc( float t )
|
||||
{
|
||||
const float p1 = (6.f/29.f)*(6.f/29.f)*(6.f/29.f);
|
||||
const float p2 = (1.f/3.f)*(29.f/6.f)*(29.f/6.f);
|
||||
const float p3 = (4.f/29.f);
|
||||
|
||||
if( t > p1 )
|
||||
{
|
||||
return pow( t, 1.f/3.f );
|
||||
}
|
||||
else
|
||||
{
|
||||
return p2 * t + p3;
|
||||
}
|
||||
}
|
||||
|
||||
Lab::Lab( const XYZ& xyz )
|
||||
{
|
||||
L = 116 * labfunc( xyz.y * rwhite.y ) - 16;
|
||||
a = 500 * ( labfunc( xyz.x * rwhite.x ) - labfunc( xyz.y * rwhite.y ) );
|
||||
b = 200 * ( labfunc( xyz.y * rwhite.y ) - labfunc( xyz.z * rwhite.z ) );
|
||||
}
|
||||
|
||||
Lab::Lab( const v3b& rgb )
|
||||
{
|
||||
new(this) Lab( XYZ( rgb ) );
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,36 +0,0 @@
|
|||
#ifndef __DARKRL__COLORSPACE_HPP__
|
||||
#define __DARKRL__COLORSPACE_HPP__
|
||||
|
||||
#include "Vector.hpp"
|
||||
|
||||
namespace Color
|
||||
{
|
||||
|
||||
class Lab;
|
||||
|
||||
class XYZ
|
||||
{
|
||||
public:
|
||||
XYZ( float x, float y, float z );
|
||||
XYZ( const v3b& rgb );
|
||||
XYZ( const Lab& lab );
|
||||
|
||||
v3i RGB() const;
|
||||
|
||||
float x, y, z;
|
||||
};
|
||||
|
||||
class Lab
|
||||
{
|
||||
public:
|
||||
Lab();
|
||||
Lab( float L, float a, float b );
|
||||
Lab( const XYZ& xyz );
|
||||
Lab( const v3b& rgb );
|
||||
|
||||
float L, a, b;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
@ -1,77 +0,0 @@
|
|||
#include <assert.h>
|
||||
#include <utility>
|
||||
|
||||
#include "BitmapDownsampled.hpp"
|
||||
#include "DataProvider.hpp"
|
||||
#include "MipMap.hpp"
|
||||
|
||||
DataProvider::DataProvider( const char* fn, bool mipmap, bool bgr )
|
||||
: m_offset( 0 )
|
||||
, m_mipmap( mipmap )
|
||||
, m_done( false )
|
||||
, m_lines( 32 )
|
||||
{
|
||||
m_bmp.emplace_back( new Bitmap( fn, m_lines, bgr ) );
|
||||
m_current = m_bmp[0].get();
|
||||
}
|
||||
|
||||
DataProvider::~DataProvider()
|
||||
{
|
||||
}
|
||||
|
||||
unsigned int DataProvider::NumberOfParts() const
|
||||
{
|
||||
unsigned int parts = ( ( m_bmp[0]->Size().y / 4 ) + m_lines - 1 ) / m_lines;
|
||||
|
||||
if( m_mipmap )
|
||||
{
|
||||
v2i current = m_bmp[0]->Size();
|
||||
int levels = NumberOfMipLevels( current );
|
||||
unsigned int lines = m_lines;
|
||||
for( int i=1; i<levels; i++ )
|
||||
{
|
||||
assert( current.x != 1 || current.y != 1 );
|
||||
current.x = std::max( 1, current.x / 2 );
|
||||
current.y = std::max( 1, current.y / 2 );
|
||||
lines *= 2;
|
||||
parts += ( ( std::max( 4, current.y ) / 4 ) + lines - 1 ) / lines;
|
||||
}
|
||||
assert( current.x == 1 && current.y == 1 );
|
||||
}
|
||||
|
||||
return parts;
|
||||
}
|
||||
|
||||
DataPart DataProvider::NextPart()
|
||||
{
|
||||
assert( !m_done );
|
||||
|
||||
unsigned int lines = m_lines;
|
||||
bool done;
|
||||
|
||||
const auto ptr = m_current->NextBlock( lines, done );
|
||||
DataPart ret = {
|
||||
ptr,
|
||||
std::max<unsigned int>( 4, m_current->Size().x ),
|
||||
lines,
|
||||
m_offset
|
||||
};
|
||||
|
||||
m_offset += m_current->Size().x / 4 * lines;
|
||||
|
||||
if( done )
|
||||
{
|
||||
if( m_mipmap && ( m_current->Size().x != 1 || m_current->Size().y != 1 ) )
|
||||
{
|
||||
m_lines *= 2;
|
||||
m_bmp.emplace_back( new BitmapDownsampled( *m_current, m_lines ) );
|
||||
m_current = m_bmp[m_bmp.size()-1].get();
|
||||
}
|
||||
else
|
||||
{
|
||||
m_done = true;
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -1,41 +0,0 @@
|
|||
#ifndef __DATAPROVIDER_HPP__
|
||||
#define __DATAPROVIDER_HPP__
|
||||
|
||||
#include <memory>
|
||||
#include <stdint.h>
|
||||
#include <vector>
|
||||
|
||||
#include "Bitmap.hpp"
|
||||
|
||||
struct DataPart
|
||||
{
|
||||
const uint32_t* src;
|
||||
unsigned int width;
|
||||
unsigned int lines;
|
||||
unsigned int offset;
|
||||
};
|
||||
|
||||
class DataProvider
|
||||
{
|
||||
public:
|
||||
DataProvider( const char* fn, bool mipmap, bool bgr );
|
||||
~DataProvider();
|
||||
|
||||
unsigned int NumberOfParts() const;
|
||||
|
||||
DataPart NextPart();
|
||||
|
||||
bool Alpha() const { return m_bmp[0]->Alpha(); }
|
||||
const v2i& Size() const { return m_bmp[0]->Size(); }
|
||||
const Bitmap& ImageData() const { return *m_bmp[0]; }
|
||||
|
||||
private:
|
||||
std::vector<std::unique_ptr<Bitmap>> m_bmp;
|
||||
Bitmap* m_current;
|
||||
unsigned int m_offset;
|
||||
unsigned int m_lines;
|
||||
bool m_mipmap;
|
||||
bool m_done;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
@ -1,31 +0,0 @@
|
|||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include "Debug.hpp"
|
||||
|
||||
static std::vector<DebugLog::Callback*> s_callbacks;
|
||||
|
||||
void DebugLog::Message( const char* msg )
|
||||
{
|
||||
for( auto it = s_callbacks.begin(); it != s_callbacks.end(); ++it )
|
||||
{
|
||||
(*it)->OnDebugMessage( msg );
|
||||
}
|
||||
}
|
||||
|
||||
void DebugLog::AddCallback( Callback* c )
|
||||
{
|
||||
const auto it = std::find( s_callbacks.begin(), s_callbacks.end(), c );
|
||||
if( it == s_callbacks.end() )
|
||||
{
|
||||
s_callbacks.push_back( c );
|
||||
}
|
||||
}
|
||||
|
||||
void DebugLog::RemoveCallback( Callback* c )
|
||||
{
|
||||
const auto it = std::find( s_callbacks.begin(), s_callbacks.end(), c );
|
||||
if( it != s_callbacks.end() )
|
||||
{
|
||||
s_callbacks.erase( it );
|
||||
}
|
||||
}
|
||||
|
|
@ -1,27 +0,0 @@
|
|||
#ifndef __DARKRL__DEBUG_HPP__
|
||||
#define __DARKRL__DEBUG_HPP__
|
||||
|
||||
#ifdef DEBUG
|
||||
# include <sstream>
|
||||
# define DBGPRINT(msg) { std::stringstream __buf; __buf << msg; DebugLog::Message( __buf.str().c_str() ); }
|
||||
#else
|
||||
# define DBGPRINT(msg) ((void)0)
|
||||
#endif
|
||||
|
||||
class DebugLog
|
||||
{
|
||||
public:
|
||||
struct Callback
|
||||
{
|
||||
virtual void OnDebugMessage( const char* msg ) = 0;
|
||||
};
|
||||
|
||||
static void Message( const char* msg );
|
||||
static void AddCallback( Callback* c );
|
||||
static void RemoveCallback( Callback* c );
|
||||
|
||||
private:
|
||||
DebugLog() {}
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
@ -1,48 +0,0 @@
|
|||
#include <stdint.h>
|
||||
|
||||
#include "Error.hpp"
|
||||
#include "Math.hpp"
|
||||
|
||||
float CalcMSE3( const Bitmap& bmp, const Bitmap& out )
|
||||
{
|
||||
float err = 0;
|
||||
|
||||
const uint32_t* p1 = bmp.Data();
|
||||
const uint32_t* p2 = out.Data();
|
||||
size_t cnt = bmp.Size().x * bmp.Size().y;
|
||||
|
||||
for( size_t i=0; i<cnt; i++ )
|
||||
{
|
||||
uint32_t c1 = *p1++;
|
||||
uint32_t c2 = *p2++;
|
||||
|
||||
err += sq( ( c1 & 0x000000FF ) - ( c2 & 0x000000FF ) );
|
||||
err += sq( ( ( c1 & 0x0000FF00 ) >> 8 ) - ( ( c2 & 0x0000FF00 ) >> 8 ) );
|
||||
err += sq( ( ( c1 & 0x00FF0000 ) >> 16 ) - ( ( c2 & 0x00FF0000 ) >> 16 ) );
|
||||
}
|
||||
|
||||
err /= cnt * 3;
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
float CalcMSE1( const Bitmap& bmp, const Bitmap& out )
|
||||
{
|
||||
float err = 0;
|
||||
|
||||
const uint32_t* p1 = bmp.Data();
|
||||
const uint32_t* p2 = out.Data();
|
||||
size_t cnt = bmp.Size().x * bmp.Size().y;
|
||||
|
||||
for( size_t i=0; i<cnt; i++ )
|
||||
{
|
||||
uint32_t c1 = *p1++;
|
||||
uint32_t c2 = *p2++;
|
||||
|
||||
err += sq( ( c1 >> 24 ) - ( c2 & 0xFF ) );
|
||||
}
|
||||
|
||||
err /= cnt;
|
||||
|
||||
return err;
|
||||
}
|
||||
|
|
@ -1,9 +0,0 @@
|
|||
#ifndef __ERROR_HPP__
|
||||
#define __ERROR_HPP__
|
||||
|
||||
#include "Bitmap.hpp"
|
||||
|
||||
float CalcMSE3( const Bitmap& bmp, const Bitmap& out );
|
||||
float CalcMSE1( const Bitmap& bmp, const Bitmap& out );
|
||||
|
||||
#endif
|
||||
|
|
@ -1,11 +0,0 @@
|
|||
#ifndef __MIPMAP_HPP__
|
||||
#define __MIPMAP_HPP__
|
||||
|
||||
#include "Vector.hpp"
|
||||
|
||||
inline int NumberOfMipLevels( const v2i& size )
|
||||
{
|
||||
return (int)floor( log2( std::max( size.x, size.y ) ) ) + 1;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
@ -1,46 +0,0 @@
|
|||
#ifndef __DARKRL__SEMAPHORE_HPP__
|
||||
#define __DARKRL__SEMAPHORE_HPP__
|
||||
|
||||
#include <condition_variable>
|
||||
#include <mutex>
|
||||
|
||||
class Semaphore
|
||||
{
|
||||
public:
|
||||
Semaphore( int count ) : m_count( count ) {}
|
||||
|
||||
void lock()
|
||||
{
|
||||
std::unique_lock<std::mutex> lock( m_mutex );
|
||||
m_cv.wait( lock, [this](){ return m_count != 0; } );
|
||||
m_count--;
|
||||
}
|
||||
|
||||
void unlock()
|
||||
{
|
||||
std::lock_guard<std::mutex> lock( m_mutex );
|
||||
m_count++;
|
||||
m_cv.notify_one();
|
||||
}
|
||||
|
||||
bool try_lock()
|
||||
{
|
||||
std::lock_guard<std::mutex> lock( m_mutex );
|
||||
if( m_count == 0 )
|
||||
{
|
||||
return false;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_count--;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
std::mutex m_mutex;
|
||||
std::condition_variable m_cv;
|
||||
unsigned int m_count;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
@ -1,65 +0,0 @@
|
|||
#include <algorithm>
|
||||
#ifdef _WIN32
|
||||
# include <windows.h>
|
||||
#else
|
||||
# include <unistd.h>
|
||||
#endif
|
||||
|
||||
#include "System.hpp"
|
||||
|
||||
unsigned int System::CPUCores()
|
||||
{
|
||||
static unsigned int cores = 0;
|
||||
if( cores == 0 )
|
||||
{
|
||||
int tmp;
|
||||
#ifdef _WIN32
|
||||
SYSTEM_INFO info;
|
||||
GetSystemInfo( &info );
|
||||
tmp = (int)info.dwNumberOfProcessors;
|
||||
#else
|
||||
# ifndef _SC_NPROCESSORS_ONLN
|
||||
# ifdef _SC_NPROC_ONLN
|
||||
# define _SC_NPROCESSORS_ONLN _SC_NPROC_ONLN
|
||||
# elif defined _SC_CRAY_NCPU
|
||||
# define _SC_NPROCESSORS_ONLN _SC_CRAY_NCPU
|
||||
# endif
|
||||
# endif
|
||||
tmp = (int)(long)sysconf( _SC_NPROCESSORS_ONLN );
|
||||
#endif
|
||||
cores = (unsigned int)std::max( tmp, 1 );
|
||||
}
|
||||
return cores;
|
||||
}
|
||||
|
||||
void System::SetThreadName( std::thread& thread, const char* name )
|
||||
{
|
||||
#ifdef _MSC_VER
|
||||
const DWORD MS_VC_EXCEPTION=0x406D1388;
|
||||
|
||||
# pragma pack( push, 8 )
|
||||
struct THREADNAME_INFO
|
||||
{
|
||||
DWORD dwType;
|
||||
LPCSTR szName;
|
||||
DWORD dwThreadID;
|
||||
DWORD dwFlags;
|
||||
};
|
||||
# pragma pack(pop)
|
||||
|
||||
DWORD ThreadId = GetThreadId( static_cast<HANDLE>( thread.native_handle() ) );
|
||||
THREADNAME_INFO info;
|
||||
info.dwType = 0x1000;
|
||||
info.szName = name;
|
||||
info.dwThreadID = ThreadId;
|
||||
info.dwFlags = 0;
|
||||
|
||||
__try
|
||||
{
|
||||
RaiseException( MS_VC_EXCEPTION, 0, sizeof(info)/sizeof(ULONG_PTR), (ULONG_PTR*)&info );
|
||||
}
|
||||
__except(EXCEPTION_EXECUTE_HANDLER)
|
||||
{
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
|
@ -1,15 +0,0 @@
|
|||
#ifndef __DARKRL__SYSTEM_HPP__
|
||||
#define __DARKRL__SYSTEM_HPP__
|
||||
|
||||
#include <thread>
|
||||
|
||||
class System
|
||||
{
|
||||
public:
|
||||
System() = delete;
|
||||
|
||||
static unsigned int CPUCores();
|
||||
static void SetThreadName( std::thread& thread, const char* name );
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
@ -1,122 +0,0 @@
|
|||
#include <assert.h>
|
||||
#include <stdio.h>
|
||||
#ifndef _MSC_VER
|
||||
#include <pthread.h>
|
||||
#endif
|
||||
|
||||
#include "Debug.hpp"
|
||||
#include "System.hpp"
|
||||
#include "TaskDispatch.hpp"
|
||||
|
||||
static TaskDispatch* s_instance = nullptr;
|
||||
|
||||
TaskDispatch::TaskDispatch( size_t workers )
|
||||
: m_exit( false )
|
||||
, m_jobs( 0 )
|
||||
{
|
||||
assert( !s_instance );
|
||||
s_instance = this;
|
||||
|
||||
assert( workers >= 1 );
|
||||
workers--;
|
||||
|
||||
m_workers.reserve( workers );
|
||||
for( size_t i=0; i<workers; i++ )
|
||||
{
|
||||
char tmp[16];
|
||||
sprintf( tmp, "Worker %zu", i );
|
||||
#ifdef _MSC_VER
|
||||
auto worker = std::thread( [this]{ Worker(); } );
|
||||
System::SetThreadName( worker, tmp );
|
||||
#else // Using pthread.
|
||||
auto worker = std::thread( [this, tmp]{
|
||||
#ifdef __APPLE__
|
||||
pthread_setname_np( tmp );
|
||||
#else // Linux or MinGW.
|
||||
pthread_setname_np( pthread_self(), tmp );
|
||||
#endif
|
||||
Worker();
|
||||
} );
|
||||
#endif
|
||||
m_workers.emplace_back( std::move( worker ) );
|
||||
}
|
||||
|
||||
DBGPRINT( "Task dispatcher with " << m_workers.size() + 1 << " workers" );
|
||||
}
|
||||
|
||||
TaskDispatch::~TaskDispatch()
|
||||
{
|
||||
m_exit = true;
|
||||
m_queueLock.lock();
|
||||
m_cvWork.notify_all();
|
||||
m_queueLock.unlock();
|
||||
|
||||
for( auto& worker : m_workers )
|
||||
{
|
||||
worker.join();
|
||||
}
|
||||
|
||||
assert( s_instance );
|
||||
s_instance = nullptr;
|
||||
}
|
||||
|
||||
void TaskDispatch::Queue( const std::function<void(void)>& f )
|
||||
{
|
||||
std::unique_lock<std::mutex> lock( s_instance->m_queueLock );
|
||||
s_instance->m_queue.emplace_back( f );
|
||||
const auto size = s_instance->m_queue.size();
|
||||
lock.unlock();
|
||||
if( size > 1 )
|
||||
{
|
||||
s_instance->m_cvWork.notify_one();
|
||||
}
|
||||
}
|
||||
|
||||
void TaskDispatch::Queue( std::function<void(void)>&& f )
|
||||
{
|
||||
std::unique_lock<std::mutex> lock( s_instance->m_queueLock );
|
||||
s_instance->m_queue.emplace_back( std::move( f ) );
|
||||
const auto size = s_instance->m_queue.size();
|
||||
lock.unlock();
|
||||
if( size > 1 )
|
||||
{
|
||||
s_instance->m_cvWork.notify_one();
|
||||
}
|
||||
}
|
||||
|
||||
void TaskDispatch::Sync()
|
||||
{
|
||||
std::unique_lock<std::mutex> lock( s_instance->m_queueLock );
|
||||
while( !s_instance->m_queue.empty() )
|
||||
{
|
||||
auto f = s_instance->m_queue.back();
|
||||
s_instance->m_queue.pop_back();
|
||||
lock.unlock();
|
||||
f();
|
||||
lock.lock();
|
||||
}
|
||||
s_instance->m_cvJobs.wait( lock, []{ return s_instance->m_jobs == 0; } );
|
||||
}
|
||||
|
||||
void TaskDispatch::Worker()
|
||||
{
|
||||
for(;;)
|
||||
{
|
||||
std::unique_lock<std::mutex> lock( m_queueLock );
|
||||
m_cvWork.wait( lock, [this]{ return !m_queue.empty() || m_exit; } );
|
||||
if( m_exit ) return;
|
||||
auto f = m_queue.back();
|
||||
m_queue.pop_back();
|
||||
m_jobs++;
|
||||
lock.unlock();
|
||||
f();
|
||||
lock.lock();
|
||||
m_jobs--;
|
||||
bool notify = m_jobs == 0 && m_queue.empty();
|
||||
lock.unlock();
|
||||
if( notify )
|
||||
{
|
||||
m_cvJobs.notify_all();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1,34 +0,0 @@
|
|||
#ifndef __DARKRL__TASKDISPATCH_HPP__
|
||||
#define __DARKRL__TASKDISPATCH_HPP__
|
||||
|
||||
#include <atomic>
|
||||
#include <condition_variable>
|
||||
#include <functional>
|
||||
#include <mutex>
|
||||
#include <thread>
|
||||
#include <vector>
|
||||
|
||||
class TaskDispatch
|
||||
{
|
||||
public:
|
||||
TaskDispatch( size_t workers );
|
||||
~TaskDispatch();
|
||||
|
||||
static void Queue( const std::function<void(void)>& f );
|
||||
static void Queue( std::function<void(void)>&& f );
|
||||
|
||||
static void Sync();
|
||||
|
||||
private:
|
||||
void Worker();
|
||||
|
||||
std::vector<std::function<void(void)>> m_queue;
|
||||
std::mutex m_queueLock;
|
||||
std::condition_variable m_cvWork, m_cvJobs;
|
||||
std::atomic<bool> m_exit;
|
||||
size_t m_jobs;
|
||||
|
||||
std::vector<std::thread> m_workers;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
@ -1,8 +0,0 @@
|
|||
#include <chrono>
|
||||
|
||||
#include "Timing.hpp"
|
||||
|
||||
uint64_t GetTime()
|
||||
{
|
||||
return std::chrono::time_point_cast<std::chrono::microseconds>( std::chrono::high_resolution_clock::now() ).time_since_epoch().count();
|
||||
}
|
||||
|
|
@ -1,8 +0,0 @@
|
|||
#ifndef __DARKRL__TIMING_HPP__
|
||||
#define __DARKRL__TIMING_HPP__
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
uint64_t GetTime();
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -1,360 +0,0 @@
|
|||
/*
|
||||
LZ4 - Fast LZ compression algorithm
|
||||
Header File
|
||||
Copyright (C) 2011-2015, Yann Collet.
|
||||
|
||||
BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are
|
||||
met:
|
||||
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above
|
||||
copyright notice, this list of conditions and the following disclaimer
|
||||
in the documentation and/or other materials provided with the
|
||||
distribution.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
You can contact the author at :
|
||||
- LZ4 source repository : https://github.com/Cyan4973/lz4
|
||||
- LZ4 public forum : https://groups.google.com/forum/#!forum/lz4c
|
||||
*/
|
||||
#pragma once
|
||||
|
||||
#if defined (__cplusplus)
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/*
|
||||
* lz4.h provides block compression functions, and gives full buffer control to programmer.
|
||||
* If you need to generate inter-operable compressed data (respecting LZ4 frame specification),
|
||||
* and can let the library handle its own memory, please use lz4frame.h instead.
|
||||
*/
|
||||
|
||||
/**************************************
|
||||
* Version
|
||||
**************************************/
|
||||
#define LZ4_VERSION_MAJOR 1 /* for breaking interface changes */
|
||||
#define LZ4_VERSION_MINOR 7 /* for new (non-breaking) interface capabilities */
|
||||
#define LZ4_VERSION_RELEASE 1 /* for tweaks, bug-fixes, or development */
|
||||
#define LZ4_VERSION_NUMBER (LZ4_VERSION_MAJOR *100*100 + LZ4_VERSION_MINOR *100 + LZ4_VERSION_RELEASE)
|
||||
int LZ4_versionNumber (void);
|
||||
|
||||
/**************************************
|
||||
* Tuning parameter
|
||||
**************************************/
|
||||
/*
|
||||
* LZ4_MEMORY_USAGE :
|
||||
* Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)
|
||||
* Increasing memory usage improves compression ratio
|
||||
* Reduced memory usage can improve speed, due to cache effect
|
||||
* Default value is 14, for 16KB, which nicely fits into Intel x86 L1 cache
|
||||
*/
|
||||
#define LZ4_MEMORY_USAGE 14
|
||||
|
||||
|
||||
/**************************************
|
||||
* Simple Functions
|
||||
**************************************/
|
||||
|
||||
int LZ4_compress_default(const char* source, char* dest, int sourceSize, int maxDestSize);
|
||||
int LZ4_decompress_safe (const char* source, char* dest, int compressedSize, int maxDecompressedSize);
|
||||
|
||||
/*
|
||||
LZ4_compress_default() :
|
||||
Compresses 'sourceSize' bytes from buffer 'source'
|
||||
into already allocated 'dest' buffer of size 'maxDestSize'.
|
||||
Compression is guaranteed to succeed if 'maxDestSize' >= LZ4_compressBound(sourceSize).
|
||||
It also runs faster, so it's a recommended setting.
|
||||
If the function cannot compress 'source' into a more limited 'dest' budget,
|
||||
compression stops *immediately*, and the function result is zero.
|
||||
As a consequence, 'dest' content is not valid.
|
||||
This function never writes outside 'dest' buffer, nor read outside 'source' buffer.
|
||||
sourceSize : Max supported value is LZ4_MAX_INPUT_VALUE
|
||||
maxDestSize : full or partial size of buffer 'dest' (which must be already allocated)
|
||||
return : the number of bytes written into buffer 'dest' (necessarily <= maxOutputSize)
|
||||
or 0 if compression fails
|
||||
|
||||
LZ4_decompress_safe() :
|
||||
compressedSize : is the precise full size of the compressed block.
|
||||
maxDecompressedSize : is the size of destination buffer, which must be already allocated.
|
||||
return : the number of bytes decompressed into destination buffer (necessarily <= maxDecompressedSize)
|
||||
If destination buffer is not large enough, decoding will stop and output an error code (<0).
|
||||
If the source stream is detected malformed, the function will stop decoding and return a negative result.
|
||||
This function is protected against buffer overflow exploits, including malicious data packets.
|
||||
It never writes outside output buffer, nor reads outside input buffer.
|
||||
*/
|
||||
|
||||
|
||||
/**************************************
|
||||
* Advanced Functions
|
||||
**************************************/
|
||||
#define LZ4_MAX_INPUT_SIZE 0x7E000000 /* 2 113 929 216 bytes */
|
||||
#define LZ4_COMPRESSBOUND(isize) ((unsigned)(isize) > (unsigned)LZ4_MAX_INPUT_SIZE ? 0 : (isize) + ((isize)/255) + 16)
|
||||
|
||||
/*
|
||||
LZ4_compressBound() :
|
||||
Provides the maximum size that LZ4 compression may output in a "worst case" scenario (input data not compressible)
|
||||
This function is primarily useful for memory allocation purposes (destination buffer size).
|
||||
Macro LZ4_COMPRESSBOUND() is also provided for compilation-time evaluation (stack memory allocation for example).
|
||||
Note that LZ4_compress_default() compress faster when dest buffer size is >= LZ4_compressBound(srcSize)
|
||||
inputSize : max supported value is LZ4_MAX_INPUT_SIZE
|
||||
return : maximum output size in a "worst case" scenario
|
||||
or 0, if input size is too large ( > LZ4_MAX_INPUT_SIZE)
|
||||
*/
|
||||
int LZ4_compressBound(int inputSize);
|
||||
|
||||
/*
|
||||
LZ4_compress_fast() :
|
||||
Same as LZ4_compress_default(), but allows to select an "acceleration" factor.
|
||||
The larger the acceleration value, the faster the algorithm, but also the lesser the compression.
|
||||
It's a trade-off. It can be fine tuned, with each successive value providing roughly +~3% to speed.
|
||||
An acceleration value of "1" is the same as regular LZ4_compress_default()
|
||||
Values <= 0 will be replaced by ACCELERATION_DEFAULT (see lz4.c), which is 1.
|
||||
*/
|
||||
int LZ4_compress_fast (const char* source, char* dest, int sourceSize, int maxDestSize, int acceleration);
|
||||
|
||||
|
||||
/*
|
||||
LZ4_compress_fast_extState() :
|
||||
Same compression function, just using an externally allocated memory space to store compression state.
|
||||
Use LZ4_sizeofState() to know how much memory must be allocated,
|
||||
and allocate it on 8-bytes boundaries (using malloc() typically).
|
||||
Then, provide it as 'void* state' to compression function.
|
||||
*/
|
||||
int LZ4_sizeofState(void);
|
||||
int LZ4_compress_fast_extState (void* state, const char* source, char* dest, int inputSize, int maxDestSize, int acceleration);
|
||||
|
||||
|
||||
/*
|
||||
LZ4_compress_destSize() :
|
||||
Reverse the logic, by compressing as much data as possible from 'source' buffer
|
||||
into already allocated buffer 'dest' of size 'targetDestSize'.
|
||||
This function either compresses the entire 'source' content into 'dest' if it's large enough,
|
||||
or fill 'dest' buffer completely with as much data as possible from 'source'.
|
||||
*sourceSizePtr : will be modified to indicate how many bytes where read from 'source' to fill 'dest'.
|
||||
New value is necessarily <= old value.
|
||||
return : Nb bytes written into 'dest' (necessarily <= targetDestSize)
|
||||
or 0 if compression fails
|
||||
*/
|
||||
int LZ4_compress_destSize (const char* source, char* dest, int* sourceSizePtr, int targetDestSize);
|
||||
|
||||
|
||||
/*
|
||||
LZ4_decompress_fast() :
|
||||
originalSize : is the original and therefore uncompressed size
|
||||
return : the number of bytes read from the source buffer (in other words, the compressed size)
|
||||
If the source stream is detected malformed, the function will stop decoding and return a negative result.
|
||||
Destination buffer must be already allocated. Its size must be a minimum of 'originalSize' bytes.
|
||||
note : This function fully respect memory boundaries for properly formed compressed data.
|
||||
It is a bit faster than LZ4_decompress_safe().
|
||||
However, it does not provide any protection against intentionally modified data stream (malicious input).
|
||||
Use this function in trusted environment only (data to decode comes from a trusted source).
|
||||
*/
|
||||
int LZ4_decompress_fast (const char* source, char* dest, int originalSize);
|
||||
|
||||
/*
|
||||
LZ4_decompress_safe_partial() :
|
||||
This function decompress a compressed block of size 'compressedSize' at position 'source'
|
||||
into destination buffer 'dest' of size 'maxDecompressedSize'.
|
||||
The function tries to stop decompressing operation as soon as 'targetOutputSize' has been reached,
|
||||
reducing decompression time.
|
||||
return : the number of bytes decoded in the destination buffer (necessarily <= maxDecompressedSize)
|
||||
Note : this number can be < 'targetOutputSize' should the compressed block to decode be smaller.
|
||||
Always control how many bytes were decoded.
|
||||
If the source stream is detected malformed, the function will stop decoding and return a negative result.
|
||||
This function never writes outside of output buffer, and never reads outside of input buffer. It is therefore protected against malicious data packets
|
||||
*/
|
||||
int LZ4_decompress_safe_partial (const char* source, char* dest, int compressedSize, int targetOutputSize, int maxDecompressedSize);
|
||||
|
||||
|
||||
/***********************************************
|
||||
* Streaming Compression Functions
|
||||
***********************************************/
|
||||
#define LZ4_STREAMSIZE_U64 ((1 << (LZ4_MEMORY_USAGE-3)) + 4)
|
||||
#define LZ4_STREAMSIZE (LZ4_STREAMSIZE_U64 * sizeof(long long))
|
||||
/*
|
||||
* LZ4_stream_t
|
||||
* information structure to track an LZ4 stream.
|
||||
* important : init this structure content before first use !
|
||||
* note : only allocated directly the structure if you are statically linking LZ4
|
||||
* If you are using liblz4 as a DLL, please use below construction methods instead.
|
||||
*/
|
||||
typedef struct { long long table[LZ4_STREAMSIZE_U64]; } LZ4_stream_t;
|
||||
|
||||
/*
|
||||
* LZ4_resetStream
|
||||
* Use this function to init an allocated LZ4_stream_t structure
|
||||
*/
|
||||
void LZ4_resetStream (LZ4_stream_t* streamPtr);
|
||||
|
||||
/*
|
||||
* LZ4_createStream will allocate and initialize an LZ4_stream_t structure
|
||||
* LZ4_freeStream releases its memory.
|
||||
* In the context of a DLL (liblz4), please use these methods rather than the static struct.
|
||||
* They are more future proof, in case of a change of LZ4_stream_t size.
|
||||
*/
|
||||
LZ4_stream_t* LZ4_createStream(void);
|
||||
int LZ4_freeStream (LZ4_stream_t* streamPtr);
|
||||
|
||||
/*
|
||||
* LZ4_loadDict
|
||||
* Use this function to load a static dictionary into LZ4_stream.
|
||||
* Any previous data will be forgotten, only 'dictionary' will remain in memory.
|
||||
* Loading a size of 0 is allowed.
|
||||
* Return : dictionary size, in bytes (necessarily <= 64 KB)
|
||||
*/
|
||||
int LZ4_loadDict (LZ4_stream_t* streamPtr, const char* dictionary, int dictSize);
|
||||
|
||||
/*
|
||||
* LZ4_compress_fast_continue
|
||||
* Compress buffer content 'src', using data from previously compressed blocks as dictionary to improve compression ratio.
|
||||
* Important : Previous data blocks are assumed to still be present and unmodified !
|
||||
* 'dst' buffer must be already allocated.
|
||||
* If maxDstSize >= LZ4_compressBound(srcSize), compression is guaranteed to succeed, and runs faster.
|
||||
* If not, and if compressed data cannot fit into 'dst' buffer size, compression stops, and function returns a zero.
|
||||
*/
|
||||
int LZ4_compress_fast_continue (LZ4_stream_t* streamPtr, const char* src, char* dst, int srcSize, int maxDstSize, int acceleration);
|
||||
|
||||
/*
|
||||
* LZ4_saveDict
|
||||
* If previously compressed data block is not guaranteed to remain available at its memory location
|
||||
* save it into a safer place (char* safeBuffer)
|
||||
* Note : you don't need to call LZ4_loadDict() afterwards,
|
||||
* dictionary is immediately usable, you can therefore call LZ4_compress_fast_continue()
|
||||
* Return : saved dictionary size in bytes (necessarily <= dictSize), or 0 if error
|
||||
*/
|
||||
int LZ4_saveDict (LZ4_stream_t* streamPtr, char* safeBuffer, int dictSize);
|
||||
|
||||
|
||||
/************************************************
|
||||
* Streaming Decompression Functions
|
||||
************************************************/
|
||||
|
||||
#define LZ4_STREAMDECODESIZE_U64 4
|
||||
#define LZ4_STREAMDECODESIZE (LZ4_STREAMDECODESIZE_U64 * sizeof(unsigned long long))
|
||||
typedef struct { unsigned long long table[LZ4_STREAMDECODESIZE_U64]; } LZ4_streamDecode_t;
|
||||
/*
|
||||
* LZ4_streamDecode_t
|
||||
* information structure to track an LZ4 stream.
|
||||
* init this structure content using LZ4_setStreamDecode or memset() before first use !
|
||||
*
|
||||
* In the context of a DLL (liblz4) please prefer usage of construction methods below.
|
||||
* They are more future proof, in case of a change of LZ4_streamDecode_t size in the future.
|
||||
* LZ4_createStreamDecode will allocate and initialize an LZ4_streamDecode_t structure
|
||||
* LZ4_freeStreamDecode releases its memory.
|
||||
*/
|
||||
LZ4_streamDecode_t* LZ4_createStreamDecode(void);
|
||||
int LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream);
|
||||
|
||||
/*
|
||||
* LZ4_setStreamDecode
|
||||
* Use this function to instruct where to find the dictionary.
|
||||
* Setting a size of 0 is allowed (same effect as reset).
|
||||
* Return : 1 if OK, 0 if error
|
||||
*/
|
||||
int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize);
|
||||
|
||||
/*
|
||||
*_continue() :
|
||||
These decoding functions allow decompression of multiple blocks in "streaming" mode.
|
||||
Previously decoded blocks *must* remain available at the memory position where they were decoded (up to 64 KB)
|
||||
In the case of a ring buffers, decoding buffer must be either :
|
||||
- Exactly same size as encoding buffer, with same update rule (block boundaries at same positions)
|
||||
In which case, the decoding & encoding ring buffer can have any size, including very small ones ( < 64 KB).
|
||||
- Larger than encoding buffer, by a minimum of maxBlockSize more bytes.
|
||||
maxBlockSize is implementation dependent. It's the maximum size you intend to compress into a single block.
|
||||
In which case, encoding and decoding buffers do not need to be synchronized,
|
||||
and encoding ring buffer can have any size, including small ones ( < 64 KB).
|
||||
- _At least_ 64 KB + 8 bytes + maxBlockSize.
|
||||
In which case, encoding and decoding buffers do not need to be synchronized,
|
||||
and encoding ring buffer can have any size, including larger than decoding buffer.
|
||||
Whenever these conditions are not possible, save the last 64KB of decoded data into a safe buffer,
|
||||
and indicate where it is saved using LZ4_setStreamDecode()
|
||||
*/
|
||||
int LZ4_decompress_safe_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int compressedSize, int maxDecompressedSize);
|
||||
int LZ4_decompress_fast_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int originalSize);
|
||||
|
||||
|
||||
/*
|
||||
Advanced decoding functions :
|
||||
*_usingDict() :
|
||||
These decoding functions work the same as
|
||||
a combination of LZ4_setStreamDecode() followed by LZ4_decompress_x_continue()
|
||||
They are stand-alone. They don't need nor update an LZ4_streamDecode_t structure.
|
||||
*/
|
||||
int LZ4_decompress_safe_usingDict (const char* source, char* dest, int compressedSize, int maxDecompressedSize, const char* dictStart, int dictSize);
|
||||
int LZ4_decompress_fast_usingDict (const char* source, char* dest, int originalSize, const char* dictStart, int dictSize);
|
||||
|
||||
|
||||
|
||||
/**************************************
|
||||
* Obsolete Functions
|
||||
**************************************/
|
||||
/* Deprecate Warnings */
|
||||
/* Should these warnings messages be a problem,
|
||||
it is generally possible to disable them,
|
||||
with -Wno-deprecated-declarations for gcc
|
||||
or _CRT_SECURE_NO_WARNINGS in Visual for example.
|
||||
You can also define LZ4_DEPRECATE_WARNING_DEFBLOCK. */
|
||||
#ifndef LZ4_DEPRECATE_WARNING_DEFBLOCK
|
||||
# define LZ4_DEPRECATE_WARNING_DEFBLOCK
|
||||
# define LZ4_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
|
||||
# if (LZ4_GCC_VERSION >= 405) || defined(__clang__)
|
||||
# define LZ4_DEPRECATED(message) __attribute__((deprecated(message)))
|
||||
# elif (LZ4_GCC_VERSION >= 301)
|
||||
# define LZ4_DEPRECATED(message) __attribute__((deprecated))
|
||||
# elif defined(_MSC_VER)
|
||||
# define LZ4_DEPRECATED(message) __declspec(deprecated(message))
|
||||
# else
|
||||
# pragma message("WARNING: You need to implement LZ4_DEPRECATED for this compiler")
|
||||
# define LZ4_DEPRECATED(message)
|
||||
# endif
|
||||
#endif /* LZ4_DEPRECATE_WARNING_DEFBLOCK */
|
||||
|
||||
/* Obsolete compression functions */
|
||||
/* These functions are planned to start generate warnings by r131 approximately */
|
||||
int LZ4_compress (const char* source, char* dest, int sourceSize);
|
||||
int LZ4_compress_limitedOutput (const char* source, char* dest, int sourceSize, int maxOutputSize);
|
||||
int LZ4_compress_withState (void* state, const char* source, char* dest, int inputSize);
|
||||
int LZ4_compress_limitedOutput_withState (void* state, const char* source, char* dest, int inputSize, int maxOutputSize);
|
||||
int LZ4_compress_continue (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize);
|
||||
int LZ4_compress_limitedOutput_continue (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize, int maxOutputSize);
|
||||
|
||||
/* Obsolete decompression functions */
|
||||
/* These function names are completely deprecated and must no longer be used.
|
||||
They are only provided here for compatibility with older programs.
|
||||
- LZ4_uncompress is the same as LZ4_decompress_fast
|
||||
- LZ4_uncompress_unknownOutputSize is the same as LZ4_decompress_safe
|
||||
These function prototypes are now disabled; uncomment them only if you really need them.
|
||||
It is highly recommended to stop using these prototypes and migrate to maintained ones */
|
||||
/* int LZ4_uncompress (const char* source, char* dest, int outputSize); */
|
||||
/* int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize, int maxOutputSize); */
|
||||
|
||||
/* Obsolete streaming functions; use new streaming interface whenever possible */
|
||||
LZ4_DEPRECATED("use LZ4_createStream() instead") void* LZ4_create (char* inputBuffer);
|
||||
LZ4_DEPRECATED("use LZ4_createStream() instead") int LZ4_sizeofStreamState(void);
|
||||
LZ4_DEPRECATED("use LZ4_resetStream() instead") int LZ4_resetStreamState(void* state, char* inputBuffer);
|
||||
LZ4_DEPRECATED("use LZ4_saveDict() instead") char* LZ4_slideInputBuffer (void* state);
|
||||
|
||||
/* Obsolete streaming decoding functions */
|
||||
LZ4_DEPRECATED("use LZ4_decompress_safe_usingDict() instead") int LZ4_decompress_safe_withPrefix64k (const char* src, char* dst, int compressedSize, int maxDstSize);
|
||||
LZ4_DEPRECATED("use LZ4_decompress_fast_usingDict() instead") int LZ4_decompress_fast_withPrefix64k (const char* src, char* dst, int originalSize);
|
||||
|
||||
|
||||
#if defined (__cplusplus)
|
||||
}
|
||||
#endif
|
||||
|
|
@ -1,38 +0,0 @@
|
|||
#include "mmap.hpp"
|
||||
|
||||
#ifdef _WIN32
|
||||
# include <io.h>
|
||||
# include <windows.h>
|
||||
|
||||
void* mmap( void* addr, size_t length, int prot, int flags, int fd, off_t offset )
|
||||
{
|
||||
HANDLE hnd;
|
||||
void* map = nullptr;
|
||||
|
||||
switch( prot )
|
||||
{
|
||||
case PROT_READ:
|
||||
if( hnd = CreateFileMapping( HANDLE( _get_osfhandle( fd ) ), nullptr, PAGE_READONLY, 0, DWORD( length ), nullptr ) )
|
||||
{
|
||||
map = MapViewOfFile( hnd, FILE_MAP_READ, 0, 0, length );
|
||||
CloseHandle( hnd );
|
||||
}
|
||||
break;
|
||||
case PROT_WRITE:
|
||||
if( hnd = CreateFileMapping( HANDLE( _get_osfhandle( fd ) ), nullptr, PAGE_READWRITE, 0, DWORD( length ), nullptr ) )
|
||||
{
|
||||
map = MapViewOfFile( hnd, FILE_MAP_WRITE, 0, 0, length );
|
||||
CloseHandle( hnd );
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
return map ? (char*)map + offset : (void*)-1;
|
||||
}
|
||||
|
||||
int munmap( void* addr, size_t length )
|
||||
{
|
||||
return UnmapViewOfFile( addr ) != 0 ? 0 : -1;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
@ -1,19 +0,0 @@
|
|||
#ifndef __MMAP_HPP__
|
||||
#define __MMAP_HPP__
|
||||
|
||||
#ifndef _WIN32
|
||||
# include <sys/mman.h>
|
||||
#else
|
||||
# include <string.h>
|
||||
# include <sys/types.h>
|
||||
|
||||
# define PROT_READ 1
|
||||
# define PROT_WRITE 2
|
||||
# define MAP_SHARED 0
|
||||
|
||||
void* mmap( void* addr, size_t length, int prot, int flags, int fd, off_t offset );
|
||||
int munmap( void* addr, size_t length );
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
@ -1,13 +0,0 @@
|
|||
diff --git a/thirdparty/etcpak/Bitmap.cpp b/thirdparty/etcpak/Bitmap.cpp
|
||||
index 6aa36f5caa..ef318318ac 100644
|
||||
--- a/thirdparty/etcpak/Bitmap.cpp
|
||||
+++ b/thirdparty/etcpak/Bitmap.cpp
|
||||
@@ -3,7 +3,7 @@
|
||||
#include <string.h>
|
||||
#include <assert.h>
|
||||
|
||||
-#include "libpng/png.h"
|
||||
+#include <png.h>
|
||||
#include "lz4/lz4.h"
|
||||
|
||||
#include "Bitmap.hpp"
|
||||
|
|
@ -1,64 +0,0 @@
|
|||
diff --git a/thirdparty/etcpak/BlockData.cpp b/thirdparty/etcpak/BlockData.cpp
|
||||
index bd738085f3..395b55246b 100644
|
||||
--- a/thirdparty/etcpak/BlockData.cpp
|
||||
+++ b/thirdparty/etcpak/BlockData.cpp
|
||||
@@ -334,10 +334,10 @@ static etcpak_force_inline void DecodeT( uint64_t block, uint32_t* dst, uint32_t
|
||||
const auto c3b = clampu8( cb1 - table59T58H[codeword] );
|
||||
|
||||
const uint32_t col_tab[4] = {
|
||||
- cr0 | ( cg0 << 8 ) | ( cb0 << 16 ) | 0xFF000000,
|
||||
- c2r | ( c2g << 8 ) | ( c2b << 16 ) | 0xFF000000,
|
||||
- cr1 | ( cg1 << 8 ) | ( cb1 << 16 ) | 0xFF000000,
|
||||
- c3r | ( c3g << 8 ) | ( c3b << 16 ) | 0xFF000000
|
||||
+ uint32_t(cr0 | ( cg0 << 8 ) | ( cb0 << 16 ) | 0xFF000000),
|
||||
+ uint32_t(c2r | ( c2g << 8 ) | ( c2b << 16 ) | 0xFF000000),
|
||||
+ uint32_t(cr1 | ( cg1 << 8 ) | ( cb1 << 16 ) | 0xFF000000),
|
||||
+ uint32_t(c3r | ( c3g << 8 ) | ( c3b << 16 ) | 0xFF000000)
|
||||
};
|
||||
|
||||
const uint32_t indexes = ( block >> 32 ) & 0xFFFFFFFF;
|
||||
@@ -389,10 +389,10 @@ static etcpak_force_inline void DecodeTAlpha( uint64_t block, uint64_t alpha, ui
|
||||
const auto c3b = clampu8( cb1 - table59T58H[codeword] );
|
||||
|
||||
const uint32_t col_tab[4] = {
|
||||
- cr0 | ( cg0 << 8 ) | ( cb0 << 16 ),
|
||||
- c2r | ( c2g << 8 ) | ( c2b << 16 ),
|
||||
- cr1 | ( cg1 << 8 ) | ( cb1 << 16 ),
|
||||
- c3r | ( c3g << 8 ) | ( c3b << 16 )
|
||||
+ uint32_t(cr0 | ( cg0 << 8 ) | ( cb0 << 16 )),
|
||||
+ uint32_t(c2r | ( c2g << 8 ) | ( c2b << 16 )),
|
||||
+ uint32_t(cr1 | ( cg1 << 8 ) | ( cb1 << 16 )),
|
||||
+ uint32_t(c3r | ( c3g << 8 ) | ( c3b << 16 ))
|
||||
};
|
||||
|
||||
const uint32_t indexes = ( block >> 32 ) & 0xFFFFFFFF;
|
||||
@@ -436,10 +436,10 @@ static etcpak_force_inline void DecodeH( uint64_t block, uint32_t* dst, uint32_t
|
||||
const auto codeword = codeword_hi | codeword_lo;
|
||||
|
||||
const uint32_t col_tab[] = {
|
||||
- clampu8( r0 + table59T58H[codeword] ) | ( clampu8( g0 + table59T58H[codeword] ) << 8 ) | ( clampu8( b0 + table59T58H[codeword] ) << 16 ),
|
||||
- clampu8( r0 - table59T58H[codeword] ) | ( clampu8( g0 - table59T58H[codeword] ) << 8 ) | ( clampu8( b0 - table59T58H[codeword] ) << 16 ),
|
||||
- clampu8( r1 + table59T58H[codeword] ) | ( clampu8( g1 + table59T58H[codeword] ) << 8 ) | ( clampu8( b1 + table59T58H[codeword] ) << 16 ),
|
||||
- clampu8( r1 - table59T58H[codeword] ) | ( clampu8( g1 - table59T58H[codeword] ) << 8 ) | ( clampu8( b1 - table59T58H[codeword] ) << 16 )
|
||||
+ uint32_t(clampu8( r0 + table59T58H[codeword] ) | ( clampu8( g0 + table59T58H[codeword] ) << 8 ) | ( clampu8( b0 + table59T58H[codeword] ) << 16 )),
|
||||
+ uint32_t(clampu8( r0 - table59T58H[codeword] ) | ( clampu8( g0 - table59T58H[codeword] ) << 8 ) | ( clampu8( b0 - table59T58H[codeword] ) << 16 )),
|
||||
+ uint32_t(clampu8( r1 + table59T58H[codeword] ) | ( clampu8( g1 + table59T58H[codeword] ) << 8 ) | ( clampu8( b1 + table59T58H[codeword] ) << 16 )),
|
||||
+ uint32_t(clampu8( r1 - table59T58H[codeword] ) | ( clampu8( g1 - table59T58H[codeword] ) << 8 ) | ( clampu8( b1 - table59T58H[codeword] ) << 16 ))
|
||||
};
|
||||
|
||||
for( uint8_t j = 0; j < 4; j++ )
|
||||
@@ -483,10 +483,10 @@ static etcpak_force_inline void DecodeHAlpha( uint64_t block, uint64_t alpha, ui
|
||||
const auto tbl = g_alpha[(alpha >> 48) & 0xF];
|
||||
|
||||
const uint32_t col_tab[] = {
|
||||
- clampu8( r0 + table59T58H[codeword] ) | ( clampu8( g0 + table59T58H[codeword] ) << 8 ) | ( clampu8( b0 + table59T58H[codeword] ) << 16 ),
|
||||
- clampu8( r0 - table59T58H[codeword] ) | ( clampu8( g0 - table59T58H[codeword] ) << 8 ) | ( clampu8( b0 - table59T58H[codeword] ) << 16 ),
|
||||
- clampu8( r1 + table59T58H[codeword] ) | ( clampu8( g1 + table59T58H[codeword] ) << 8 ) | ( clampu8( b1 + table59T58H[codeword] ) << 16 ),
|
||||
- clampu8( r1 - table59T58H[codeword] ) | ( clampu8( g1 - table59T58H[codeword] ) << 8 ) | ( clampu8( b1 - table59T58H[codeword] ) << 16 )
|
||||
+ uint32_t(clampu8( r0 + table59T58H[codeword] ) | ( clampu8( g0 + table59T58H[codeword] ) << 8 ) | ( clampu8( b0 + table59T58H[codeword] ) << 16 )),
|
||||
+ uint32_t(clampu8( r0 - table59T58H[codeword] ) | ( clampu8( g0 - table59T58H[codeword] ) << 8 ) | ( clampu8( b0 - table59T58H[codeword] ) << 16 )),
|
||||
+ uint32_t(clampu8( r1 + table59T58H[codeword] ) | ( clampu8( g1 + table59T58H[codeword] ) << 8 ) | ( clampu8( b1 + table59T58H[codeword] ) << 16 )),
|
||||
+ uint32_t(clampu8( r1 - table59T58H[codeword] ) | ( clampu8( g1 - table59T58H[codeword] ) << 8 ) | ( clampu8( b1 - table59T58H[codeword] ) << 16 ))
|
||||
};
|
||||
|
||||
for( uint8_t j = 0; j < 4; j++ )
|
||||
|
|
@ -1,66 +0,0 @@
|
|||
diff --git a/thirdparty/etcpak/System.cpp b/thirdparty/etcpak/System.cpp
|
||||
index 1383d0ecd0..041f2676e8 100644
|
||||
--- a/thirdparty/etcpak/System.cpp
|
||||
+++ b/thirdparty/etcpak/System.cpp
|
||||
@@ -2,7 +2,6 @@
|
||||
#ifdef _WIN32
|
||||
# include <windows.h>
|
||||
#else
|
||||
-# include <pthread.h>
|
||||
# include <unistd.h>
|
||||
#endif
|
||||
|
||||
@@ -35,7 +34,7 @@ unsigned int System::CPUCores()
|
||||
|
||||
void System::SetThreadName( std::thread& thread, const char* name )
|
||||
{
|
||||
-#ifdef _WIN32
|
||||
+#ifdef _MSC_VER
|
||||
const DWORD MS_VC_EXCEPTION=0x406D1388;
|
||||
|
||||
# pragma pack( push, 8 )
|
||||
@@ -62,7 +61,5 @@ void System::SetThreadName( std::thread& thread, const char* name )
|
||||
__except(EXCEPTION_EXECUTE_HANDLER)
|
||||
{
|
||||
}
|
||||
-#elif !defined(__APPLE__)
|
||||
- pthread_setname_np( thread.native_handle(), name );
|
||||
#endif
|
||||
}
|
||||
diff --git a/thirdparty/etcpak/TaskDispatch.cpp b/thirdparty/etcpak/TaskDispatch.cpp
|
||||
index 7287da4de2..b1ba17953b 100644
|
||||
--- a/thirdparty/etcpak/TaskDispatch.cpp
|
||||
+++ b/thirdparty/etcpak/TaskDispatch.cpp
|
||||
@@ -1,5 +1,8 @@
|
||||
#include <assert.h>
|
||||
#include <stdio.h>
|
||||
+#ifndef _MSC_VER
|
||||
+#include <pthread.h>
|
||||
+#endif
|
||||
|
||||
#include "Debug.hpp"
|
||||
#include "System.hpp"
|
||||
@@ -22,15 +25,19 @@ TaskDispatch::TaskDispatch( size_t workers )
|
||||
{
|
||||
char tmp[16];
|
||||
sprintf( tmp, "Worker %zu", i );
|
||||
-#ifdef __APPLE__
|
||||
+#ifdef _MSC_VER
|
||||
+ auto worker = std::thread( [this]{ Worker(); } );
|
||||
+ System::SetThreadName( worker, tmp );
|
||||
+#else // Using pthread.
|
||||
auto worker = std::thread( [this, tmp]{
|
||||
+#ifdef __APPLE__
|
||||
pthread_setname_np( tmp );
|
||||
+#else // Linux or MinGW.
|
||||
+ pthread_setname_np( pthread_self(), tmp );
|
||||
+#endif
|
||||
Worker();
|
||||
} );
|
||||
-#else
|
||||
- auto worker = std::thread( [this]{ Worker(); } );
|
||||
#endif
|
||||
- System::SetThreadName( worker, tmp );
|
||||
m_workers.emplace_back( std::move( worker ) );
|
||||
}
|
||||
|
||||
|
|
@ -1,50 +0,0 @@
|
|||
diff --git a/thirdparty/etcpak/BlockData.cpp b/thirdparty/etcpak/BlockData.cpp
|
||||
index a2cd032c5b..bd738085f3 100644
|
||||
--- a/thirdparty/etcpak/BlockData.cpp
|
||||
+++ b/thirdparty/etcpak/BlockData.cpp
|
||||
@@ -15,7 +15,7 @@
|
||||
# include <arm_neon.h>
|
||||
#endif
|
||||
|
||||
-#ifdef __SSE4_1__
|
||||
+#if defined __SSE4_1__ || defined __AVX2__ || defined _MSC_VER
|
||||
# ifdef _MSC_VER
|
||||
# include <intrin.h>
|
||||
# include <Windows.h>
|
||||
@@ -24,12 +24,6 @@
|
||||
# else
|
||||
# include <x86intrin.h>
|
||||
# endif
|
||||
-#else
|
||||
-# ifndef _MSC_VER
|
||||
-# include <byteswap.h>
|
||||
-# define _bswap(x) bswap_32(x)
|
||||
-# define _bswap64(x) bswap_64(x)
|
||||
-# endif
|
||||
#endif
|
||||
|
||||
#ifndef _bswap
|
||||
diff --git a/thirdparty/etcpak/ProcessRGB.cpp b/thirdparty/etcpak/ProcessRGB.cpp
|
||||
index 220d5c55e2..9dc5a78b67 100644
|
||||
--- a/thirdparty/etcpak/ProcessRGB.cpp
|
||||
+++ b/thirdparty/etcpak/ProcessRGB.cpp
|
||||
@@ -1,5 +1,6 @@
|
||||
#include <array>
|
||||
#include <string.h>
|
||||
+#include <limits>
|
||||
|
||||
#ifdef __ARM_NEON
|
||||
# include <arm_neon.h>
|
||||
@@ -21,12 +22,6 @@
|
||||
# else
|
||||
# include <x86intrin.h>
|
||||
# endif
|
||||
-#else
|
||||
-# ifndef _MSC_VER
|
||||
-# include <byteswap.h>
|
||||
-# define _bswap(x) bswap_32(x)
|
||||
-# define _bswap64(x) bswap_64(x)
|
||||
-# endif
|
||||
#endif
|
||||
|
||||
#ifndef _bswap
|
||||
Loading…
Reference in New Issue