2273 lines
100 KiB
Text
2273 lines
100 KiB
Text
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Copyright (c) 2016, Intel Corporation
|
||
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
|
||
|
|
// documentation files (the "Software"), to deal in the Software without restriction, including without limitation
|
||
|
|
// the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
|
||
|
|
// permit persons to whom the Software is furnished to do so, subject to the following conditions:
|
||
|
|
// The above copyright notice and this permission notice shall be included in all copies or substantial portions of
|
||
|
|
// the Software.
|
||
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
|
||
|
|
// THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
||
|
|
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||
|
|
// SOFTWARE.
|
||
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
|
||
|
|
typedef int8 int8_t;
|
||
|
|
typedef int32 int32_t;
|
||
|
|
typedef int64 int64_t;
|
||
|
|
|
||
|
|
typedef unsigned int8 uint8_t;
|
||
|
|
typedef unsigned int32 uint32_t;
|
||
|
|
typedef unsigned int64 uint64_t;
|
||
|
|
|
||
|
|
///////////////////////////
|
||
|
|
// generic helpers
|
||
|
|
|
||
|
|
inline float RCP(float x)
|
||
|
|
{
|
||
|
|
return 1.0f/x; // uses rcp when compiled with --opt=fast-math
|
||
|
|
//return rcp(x);
|
||
|
|
//return rcp_fast(x);
|
||
|
|
}
|
||
|
|
|
||
|
|
inline float RSQRT(float x)
|
||
|
|
{
|
||
|
|
return 1.0f/sqrt(x); // uses rsqrt when compiled with --opt=fast-math
|
||
|
|
//return rsqrt(x);
|
||
|
|
//return rsqrt_fast(x);
|
||
|
|
}
|
||
|
|
|
||
|
|
void swap(float& a, float& b)
|
||
|
|
{
|
||
|
|
int t = a;
|
||
|
|
a = b; b = t;
|
||
|
|
}
|
||
|
|
|
||
|
|
void swap(int& a, int& b)
|
||
|
|
{
|
||
|
|
int t = a;
|
||
|
|
a = b; b = t;
|
||
|
|
}
|
||
|
|
|
||
|
|
void swap(uint32_t& a, uint32_t& b)
|
||
|
|
{
|
||
|
|
uint32_t t = a;
|
||
|
|
a = b; b = t;
|
||
|
|
}
|
||
|
|
|
||
|
|
void swap(uint8_t& a, uint8_t& b)
|
||
|
|
{
|
||
|
|
uint8_t t = a;
|
||
|
|
a = b; b = t;
|
||
|
|
}
|
||
|
|
|
||
|
|
inline float sq(float v)
|
||
|
|
{
|
||
|
|
return v*v;
|
||
|
|
}
|
||
|
|
|
||
|
|
inline float clamp(float v, int a, int b)
|
||
|
|
{
|
||
|
|
return clamp(v, (float)a, (float)b);
|
||
|
|
}
|
||
|
|
|
||
|
|
inline float dot3(float a[3], float b[3])
|
||
|
|
{
|
||
|
|
return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
|
||
|
|
}
|
||
|
|
|
||
|
|
inline float dot4(float a[4], float b[4])
|
||
|
|
{
|
||
|
|
return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
|
||
|
|
}
|
||
|
|
|
||
|
|
// the following helpers isolate performance warnings
|
||
|
|
|
||
|
|
inline uint32_t gather_uint(const uniform uint32_t* const uniform ptr, int idx)
|
||
|
|
{
|
||
|
|
return ptr[idx]; // (perf warning expected)
|
||
|
|
}
|
||
|
|
|
||
|
|
inline float gather_float(uniform float* uniform ptr, int idx)
|
||
|
|
{
|
||
|
|
return ptr[idx]; // (perf warning expected)
|
||
|
|
}
|
||
|
|
|
||
|
|
inline float gather_float(varying float* uniform ptr, int idx)
|
||
|
|
{
|
||
|
|
return ptr[idx]; // (perf warning expected)
|
||
|
|
}
|
||
|
|
|
||
|
|
inline void scatter_uint(uniform uint32_t* ptr, int idx, uint32_t value)
|
||
|
|
{
|
||
|
|
ptr[idx] = value; // (perf warning expected)
|
||
|
|
}
|
||
|
|
|
||
|
|
inline void scatter_float(uniform float* uniform ptr, int idx, float value)
|
||
|
|
{
|
||
|
|
ptr[idx] = value; // (perf warning expected)
|
||
|
|
}
|
||
|
|
|
||
|
|
inline void scatter_float(varying float* uniform ptr, int idx, float value)
|
||
|
|
{
|
||
|
|
ptr[idx] = value; // (perf warning expected)
|
||
|
|
}
|
||
|
|
|
||
|
|
///////////////////////////////////////////////////////////
|
||
|
|
// ASTC shared functions
|
||
|
|
|
||
|
|
struct rgba_surface
|
||
|
|
{
|
||
|
|
uint8_t* ptr;
|
||
|
|
int width, height, stride;
|
||
|
|
};
|
||
|
|
|
||
|
|
inline void set_pixel(float pixels[], uniform int p, uniform int x, uniform int y, float value);
|
||
|
|
|
||
|
|
inline void load_block_interleaved(float pixels[], uniform rgba_surface src[], int xx, int yy, uniform int width, uniform int height)
|
||
|
|
{
|
||
|
|
uniform int pitch = width * height;
|
||
|
|
for (uniform int y = 0; y < height; y++)
|
||
|
|
for (uniform int x = 0; x < width; x++)
|
||
|
|
{
|
||
|
|
uint32_t rgba = gather_uint((uint32_t*)src->ptr, ((yy * height + y)*src->stride + (xx * width + x) * 4)/4);
|
||
|
|
|
||
|
|
set_pixel(pixels, 0, x, y, (int)((rgba >> 0) & 255));
|
||
|
|
set_pixel(pixels, 1, x, y, (int)((rgba >> 8) & 255));
|
||
|
|
set_pixel(pixels, 2, x, y, (int)((rgba >> 16) & 255));
|
||
|
|
set_pixel(pixels, 3, x, y, (int)((rgba >> 24) & 255));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
struct astc_enc_settings
|
||
|
|
{
|
||
|
|
int block_width;
|
||
|
|
int block_height;
|
||
|
|
int channels;
|
||
|
|
|
||
|
|
int fastSkipTreshold;
|
||
|
|
int refineIterations;
|
||
|
|
};
|
||
|
|
|
||
|
|
export uniform int get_programCount()
|
||
|
|
{
|
||
|
|
return programCount;
|
||
|
|
}
|
||
|
|
|
||
|
|
inline float get_pixel(float pixels[], uniform int p, uniform int x, uniform int y)
|
||
|
|
{
|
||
|
|
uniform static const int ystride = 8;
|
||
|
|
uniform static const int pstride = 64;
|
||
|
|
|
||
|
|
return pixels[pstride * p + ystride * y + x];
|
||
|
|
}
|
||
|
|
|
||
|
|
inline void set_pixel(float pixels[], uniform int p, uniform int x, uniform int y, float value)
|
||
|
|
{
|
||
|
|
uniform static const int ystride = 8;
|
||
|
|
uniform static const int pstride = 64;
|
||
|
|
|
||
|
|
pixels[pstride * p + ystride * y + x] = value;
|
||
|
|
}
|
||
|
|
|
||
|
|
struct pixel_set
|
||
|
|
{
|
||
|
|
varying float* uniform pixels;
|
||
|
|
|
||
|
|
uniform int width;
|
||
|
|
uniform int height;
|
||
|
|
};
|
||
|
|
|
||
|
|
inline void clear_alpha(float pixels[], uniform int width, uniform int height)
|
||
|
|
{
|
||
|
|
for (uniform int y = 0; y < height; y++)
|
||
|
|
for (uniform int x = 0; x < width; x++)
|
||
|
|
{
|
||
|
|
set_pixel(pixels, 3, x, y, 255);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void rotate_plane(pixel_set block[], int p)
|
||
|
|
{
|
||
|
|
uniform int pitch = block->height * block->width;
|
||
|
|
|
||
|
|
for (uniform int y = 0; y < block->height; y++)
|
||
|
|
for (uniform int x = 0; x < block->width; x++)
|
||
|
|
{
|
||
|
|
float r = get_pixel(block->pixels, 0, x, y);
|
||
|
|
float g = get_pixel(block->pixels, 1, x, y);
|
||
|
|
float b = get_pixel(block->pixels, 2, x, y);
|
||
|
|
float a = get_pixel(block->pixels, 3, x, y);
|
||
|
|
|
||
|
|
if (p == 0) swap(a, r);
|
||
|
|
if (p == 1) swap(a, g);
|
||
|
|
if (p == 2) swap(a, b);
|
||
|
|
|
||
|
|
set_pixel(block->pixels, 0, x, y, r);
|
||
|
|
set_pixel(block->pixels, 1, x, y, g);
|
||
|
|
set_pixel(block->pixels, 2, x, y, b);
|
||
|
|
set_pixel(block->pixels, 3, x, y, a);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
inline void compute_moments(float stats[15], pixel_set block[], uniform int channels)
|
||
|
|
{
|
||
|
|
for (uniform int y = 0; y < block->height; y++)
|
||
|
|
for (uniform int x = 0; x < block->width; x++)
|
||
|
|
{
|
||
|
|
float rgba[4];
|
||
|
|
for (uniform int p = 0; p < channels; p++) rgba[p] = get_pixel(block->pixels, p, x, y);
|
||
|
|
|
||
|
|
stats[10] += rgba[0];
|
||
|
|
stats[11] += rgba[1];
|
||
|
|
stats[12] += rgba[2];
|
||
|
|
|
||
|
|
stats[0] += rgba[0] * rgba[0];
|
||
|
|
stats[1] += rgba[0] * rgba[1];
|
||
|
|
stats[2] += rgba[0] * rgba[2];
|
||
|
|
|
||
|
|
stats[4] += rgba[1] * rgba[1];
|
||
|
|
stats[5] += rgba[1] * rgba[2];
|
||
|
|
|
||
|
|
stats[7] += rgba[2] * rgba[2];
|
||
|
|
|
||
|
|
if (channels == 4)
|
||
|
|
{
|
||
|
|
stats[13] += rgba[3];
|
||
|
|
|
||
|
|
stats[3] += rgba[0] * rgba[3];
|
||
|
|
stats[6] += rgba[1] * rgba[3];
|
||
|
|
stats[8] += rgba[2] * rgba[3];
|
||
|
|
stats[9] += rgba[3] * rgba[3];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
stats[14] += block->height * block->width;
|
||
|
|
}
|
||
|
|
|
||
|
|
inline void covar_from_stats(float covar[10], float stats[15], uniform int channels)
|
||
|
|
{
|
||
|
|
covar[0] = stats[0] - stats[10 + 0] * stats[10 + 0] / stats[14];
|
||
|
|
covar[1] = stats[1] - stats[10 + 0] * stats[10 + 1] / stats[14];
|
||
|
|
covar[2] = stats[2] - stats[10 + 0] * stats[10 + 2] / stats[14];
|
||
|
|
|
||
|
|
covar[4] = stats[4] - stats[10 + 1] * stats[10 + 1] / stats[14];
|
||
|
|
covar[5] = stats[5] - stats[10 + 1] * stats[10 + 2] / stats[14];
|
||
|
|
|
||
|
|
covar[7] = stats[7] - stats[10 + 2] * stats[10 + 2] / stats[14];
|
||
|
|
|
||
|
|
if (channels == 4)
|
||
|
|
{
|
||
|
|
covar[3] = stats[3] - stats[10 + 0] * stats[10 + 3] / stats[14];
|
||
|
|
covar[6] = stats[6] - stats[10 + 1] * stats[10 + 3] / stats[14];
|
||
|
|
covar[8] = stats[8] - stats[10 + 2] * stats[10 + 3] / stats[14];
|
||
|
|
covar[9] = stats[9] - stats[10 + 3] * stats[10 + 3] / stats[14];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
inline void compute_covar_dc(float covar[], float dc[], pixel_set block[], bool zero_based, uniform int channels)
|
||
|
|
{
|
||
|
|
float stats[15] = { 0 };
|
||
|
|
compute_moments(stats, block, channels);
|
||
|
|
|
||
|
|
if (zero_based)
|
||
|
|
for (uniform int p = 0; p < 4; p++) stats[10 + p] = 0;
|
||
|
|
|
||
|
|
covar_from_stats(covar, stats, channels);
|
||
|
|
for (uniform int p = 0; p < channels; p++) dc[p] = stats[10 + p] / stats[14];
|
||
|
|
}
|
||
|
|
|
||
|
|
inline void ssymv3(float a[4], float covar[10], float b[4])
|
||
|
|
{
|
||
|
|
a[0] = covar[0] * b[0] + covar[1] * b[1] + covar[2] * b[2];
|
||
|
|
a[1] = covar[1] * b[0] + covar[4] * b[1] + covar[5] * b[2];
|
||
|
|
a[2] = covar[2] * b[0] + covar[5] * b[1] + covar[7] * b[2];
|
||
|
|
}
|
||
|
|
|
||
|
|
inline void ssymv4(float a[4], float covar[10], float b[4])
|
||
|
|
{
|
||
|
|
a[0] = covar[0] * b[0] + covar[1] * b[1] + covar[2] * b[2] + covar[3] * b[3];
|
||
|
|
a[1] = covar[1] * b[0] + covar[4] * b[1] + covar[5] * b[2] + covar[6] * b[3];
|
||
|
|
a[2] = covar[2] * b[0] + covar[5] * b[1] + covar[7] * b[2] + covar[8] * b[3];
|
||
|
|
a[3] = covar[3] * b[0] + covar[6] * b[1] + covar[8] * b[2] + covar[9] * b[3];
|
||
|
|
}
|
||
|
|
|
||
|
|
inline void compute_axis(float axis[4], float covar[10], uniform const int powerIterations, uniform int channels)
|
||
|
|
{
|
||
|
|
float vec[4] = { 1, 1, 1, 1 };
|
||
|
|
|
||
|
|
for (uniform int i = 0; i < powerIterations; i++)
|
||
|
|
{
|
||
|
|
if (channels == 3) ssymv3(axis, covar, vec);
|
||
|
|
if (channels == 4) ssymv4(axis, covar, vec);
|
||
|
|
for (uniform int p = 0; p < channels; p++) vec[p] = axis[p];
|
||
|
|
|
||
|
|
if (i % 2 == 1) // renormalize every other iteration
|
||
|
|
{
|
||
|
|
float norm_sq = 0;
|
||
|
|
for (uniform int p = 0; p < channels; p++)
|
||
|
|
norm_sq += axis[p] * axis[p];
|
||
|
|
|
||
|
|
float rnorm = RSQRT(norm_sq);
|
||
|
|
for (uniform int p = 0; p < channels; p++) vec[p] *= rnorm;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
for (uniform int p = 0; p < channels; p++) axis[p] = vec[p];
|
||
|
|
}
|
||
|
|
|
||
|
|
void compute_pca_endpoints(float ep[8], pixel_set block[], bool zero_based, uniform int channels)
|
||
|
|
{
|
||
|
|
float dc[4];
|
||
|
|
float cov[10];
|
||
|
|
compute_covar_dc(cov, dc, block, zero_based, channels);
|
||
|
|
|
||
|
|
uniform int powerIterations = 10;
|
||
|
|
|
||
|
|
float eps = sq(0.001) * 1000;
|
||
|
|
cov[0] += eps;
|
||
|
|
cov[4] += eps;
|
||
|
|
cov[7] += eps;
|
||
|
|
cov[9] += eps;
|
||
|
|
|
||
|
|
float dir[4];
|
||
|
|
compute_axis(dir, cov, powerIterations, channels);
|
||
|
|
|
||
|
|
float ext[2] = { 1000, -1000 };
|
||
|
|
|
||
|
|
for (uniform int y = 0; y < block->height; y++)
|
||
|
|
for (uniform int x = 0; x < block->width; x++)
|
||
|
|
{
|
||
|
|
float proj = 0;
|
||
|
|
for (uniform int p = 0; p < channels; p++) proj += (get_pixel(block->pixels, p, x, y) - dc[p]) * dir[p];
|
||
|
|
|
||
|
|
ext[0] = min(ext[0], proj);
|
||
|
|
ext[1] = max(ext[1], proj);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ext[1] - 1.0f < ext[0])
|
||
|
|
{
|
||
|
|
ext[1] += 0.5f;
|
||
|
|
ext[0] -= 0.5f;
|
||
|
|
}
|
||
|
|
|
||
|
|
for (uniform int i = 0; i < 2; i++)
|
||
|
|
for (uniform int p = 0; p < channels; p++)
|
||
|
|
{
|
||
|
|
ep[p * 2 + i] = dc[p] + dir[p] * ext[i];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
uniform static const int range_table[][3] =
|
||
|
|
{
|
||
|
|
//2^ 3^ 5^
|
||
|
|
{ 1, 0, 0 }, // 0..1
|
||
|
|
{ 0, 1, 0 }, // 0..2
|
||
|
|
{ 2, 0, 0 }, // 0..3
|
||
|
|
|
||
|
|
{ 0, 0, 1 }, // 0..4
|
||
|
|
{ 1, 1, 0 }, // 0..5
|
||
|
|
{ 3, 0, 0 }, // 0..7
|
||
|
|
|
||
|
|
{ 1, 0, 1 }, // 0..9
|
||
|
|
{ 2, 1, 0 }, // 0..11
|
||
|
|
{ 4, 0, 0 }, // 0..15
|
||
|
|
|
||
|
|
{ 2, 0, 1 }, // 0..19
|
||
|
|
{ 3, 1, 0 }, // 0..23
|
||
|
|
{ 5, 0, 0 }, // 0..31
|
||
|
|
|
||
|
|
{ 3, 0, 1 }, // 0..39
|
||
|
|
{ 4, 1, 0 }, // 0..47
|
||
|
|
{ 6, 0, 0 }, // 0..63
|
||
|
|
|
||
|
|
{ 4, 0, 1 }, // 0..79
|
||
|
|
{ 5, 1, 0 }, // 0..95
|
||
|
|
{ 7, 0, 0 }, // 0..127
|
||
|
|
|
||
|
|
{ 5, 0, 1 }, // 0..159
|
||
|
|
{ 6, 1, 0 }, // 0..191
|
||
|
|
{ 8, 0, 0 }, // 0..255
|
||
|
|
};
|
||
|
|
|
||
|
|
uniform int get_levels(uniform int range)
|
||
|
|
{
|
||
|
|
return (1 + 2 * range_table[range][1] + 4 * range_table[range][2]) << range_table[range][0];
|
||
|
|
}
|
||
|
|
|
||
|
|
struct range_values
|
||
|
|
{
|
||
|
|
int levels_m;
|
||
|
|
int levels_m_rcp;
|
||
|
|
int levels_e;
|
||
|
|
int levels;
|
||
|
|
};
|
||
|
|
|
||
|
|
void fill_range_values(range_values values[], int _range[])
|
||
|
|
{
|
||
|
|
int range = *_range;
|
||
|
|
int range_div3 = (range * 21846) >> 16;
|
||
|
|
int range_mod3 = range - range_div3 * 3;
|
||
|
|
|
||
|
|
int levels_m = max(2, 5 - range_mod3 * 2);
|
||
|
|
int levels_e = max(0, range_mod3 + range_div3 - 1);
|
||
|
|
if (range == 0) levels_m = 2;
|
||
|
|
|
||
|
|
int levels_m_rcp = 0x10000 / 2 + 1;
|
||
|
|
if (levels_m == 3) levels_m_rcp = 0x10000 / 3 + 1;
|
||
|
|
if (levels_m == 5) levels_m_rcp = 0x10000 / 5 + 1;
|
||
|
|
|
||
|
|
values->levels_e = levels_e;
|
||
|
|
values->levels_m = levels_m;
|
||
|
|
values->levels_m_rcp = levels_m_rcp;
|
||
|
|
|
||
|
|
values->levels = levels_m << levels_e;
|
||
|
|
}
|
||
|
|
|
||
|
|
range_values get_range_values(int range)
|
||
|
|
{
|
||
|
|
range_values values;
|
||
|
|
fill_range_values(&values, &range);
|
||
|
|
return values;
|
||
|
|
}
|
||
|
|
|
||
|
|
int get_levels(int range)
|
||
|
|
{
|
||
|
|
int range_div3 = (range * 21846) >> 16;
|
||
|
|
int range_mod3 = range - range_div3 * 3;
|
||
|
|
|
||
|
|
int levels_m = max(2, 5 - range_mod3 * 2);
|
||
|
|
int levels_e = range_mod3 + range_div3 - 1;
|
||
|
|
|
||
|
|
return (levels_m << (levels_e + 1)) >> 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
uniform float get_sq_rcp_levels(uniform int range)
|
||
|
|
{
|
||
|
|
uniform static const float table[] =
|
||
|
|
{
|
||
|
|
1.000000, 0.250000, 0.111111,
|
||
|
|
0.062500, 0.040000, 0.020408,
|
||
|
|
0.012346, 0.008264, 0.004444,
|
||
|
|
0.002770, 0.001890, 0.001041,
|
||
|
|
0.000657, 0.000453, 0.000252,
|
||
|
|
0.000160, 0.000111, 0.000062,
|
||
|
|
0.000040, 0.000027, 0.000015,
|
||
|
|
};
|
||
|
|
|
||
|
|
return table[range];
|
||
|
|
}
|
||
|
|
|
||
|
|
///////////////////////////////////////////////////////////
|
||
|
|
// ASTC candidate ranking
|
||
|
|
|
||
|
|
struct astc_rank_state
|
||
|
|
{
|
||
|
|
float pixels[256];
|
||
|
|
|
||
|
|
float pca_error[2][5];
|
||
|
|
float alpha_error[2][5];
|
||
|
|
float sq_norm[2][5];
|
||
|
|
float scale_error[7][7]; // 2x2 to 8x8
|
||
|
|
|
||
|
|
float best_scores[64];
|
||
|
|
uint32_t best_modes[64];
|
||
|
|
|
||
|
|
// settings
|
||
|
|
uniform int block_width;
|
||
|
|
uniform int block_height;
|
||
|
|
uniform int pitch;
|
||
|
|
|
||
|
|
uniform int fastSkipTreshold;
|
||
|
|
};
|
||
|
|
|
||
|
|
struct astc_mode
|
||
|
|
{
|
||
|
|
int width;
|
||
|
|
int height;
|
||
|
|
bool dual_plane;
|
||
|
|
int weight_range;
|
||
|
|
int color_component_selector;
|
||
|
|
int partitions;
|
||
|
|
int partition_id;
|
||
|
|
int color_endpoint_pairs;
|
||
|
|
int color_endpoint_modes[2];
|
||
|
|
int endpoint_range;
|
||
|
|
};
|
||
|
|
|
||
|
|
void dct_4(float values[], uniform int stride)
|
||
|
|
{
|
||
|
|
uniform static const float scale[] = { 0.5, 0.707106769 };
|
||
|
|
uniform static const float c[5] = { 1, 0.923879533, 0.707106769, 0.382683432, 0 };
|
||
|
|
|
||
|
|
float data[4];
|
||
|
|
for (uniform int i = 0; i < 2; i++)
|
||
|
|
{
|
||
|
|
float a = values[stride * i];
|
||
|
|
float b = values[stride * (3 - i)];
|
||
|
|
data[0 + i] = a + b;
|
||
|
|
data[2 + i] = a - b;
|
||
|
|
}
|
||
|
|
|
||
|
|
for (uniform int i = 0; i < 4; i++)
|
||
|
|
{
|
||
|
|
float acc = 0;
|
||
|
|
varying float* uniform input = &data[(i % 2) * 2];
|
||
|
|
for (uniform int j = 0; j < 2; j++)
|
||
|
|
{
|
||
|
|
uniform int e = (2 * j + 1)*i;
|
||
|
|
e = e % (4 * 4);
|
||
|
|
uniform float w = 1;
|
||
|
|
if (e>8) { e = 16 - e; }
|
||
|
|
if (e>4) { w = -1; e = 8 - e; }
|
||
|
|
w *= c[e];
|
||
|
|
acc += w * input[j];
|
||
|
|
}
|
||
|
|
|
||
|
|
values[stride * i] = acc * scale[i > 0];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void dct_6(float values[], uniform int stride)
|
||
|
|
{
|
||
|
|
uniform static const float scale[] = { 0.408248290, 0.577350269 };
|
||
|
|
uniform static const float c[7] =
|
||
|
|
{ 1, 0.965925813, 0.866025388, 0.707106769, 0.500000000, 0.258819044, 0 };
|
||
|
|
|
||
|
|
float data[6];
|
||
|
|
for (uniform int i = 0; i < 3; i++)
|
||
|
|
{
|
||
|
|
float a = values[stride * i];
|
||
|
|
float b = values[stride * (5 - i)];
|
||
|
|
data[0 + i] = a + b;
|
||
|
|
data[3 + i] = a - b;
|
||
|
|
}
|
||
|
|
|
||
|
|
for (uniform int i = 0; i < 6; i++)
|
||
|
|
{
|
||
|
|
float acc = 0;
|
||
|
|
varying float* uniform input = &data[(i % 2) * 3];
|
||
|
|
for (uniform int j = 0; j < 3; j++)
|
||
|
|
{
|
||
|
|
uniform int e = (2 * j + 1)*i;
|
||
|
|
e = e % (4 * 6);
|
||
|
|
uniform float w = 1;
|
||
|
|
if (e>12) { e = 24 - e; }
|
||
|
|
if (e>6) { w = -1; e = 12 - e; }
|
||
|
|
w *= c[e];
|
||
|
|
acc += w * input[j];
|
||
|
|
}
|
||
|
|
|
||
|
|
values[stride * i] = acc * scale[i > 0];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void dct_n(float values[], uniform int stride, uniform int n)
|
||
|
|
{
|
||
|
|
uniform static const float pi = 3.14159265358979323846;
|
||
|
|
|
||
|
|
assert(n <= 16);
|
||
|
|
uniform float c[16 + 1];
|
||
|
|
for (uniform int i = 0; i <= n; i++)
|
||
|
|
c[i] = cos((i / (4.0 * n) * 2 * pi));
|
||
|
|
|
||
|
|
uniform float scale[] = { 1 / sqrt(1.0*n), 1 / sqrt(n / 2.0), };
|
||
|
|
|
||
|
|
float data[16];
|
||
|
|
for (uniform int i = 0; i < n; i++)
|
||
|
|
data[i] = values[stride * i];
|
||
|
|
|
||
|
|
for (uniform int i = 0; i < n; i++)
|
||
|
|
{
|
||
|
|
float acc = 0;
|
||
|
|
for (uniform int j = 0; j < n; j++)
|
||
|
|
{
|
||
|
|
uniform int e = (2 * j + 1)*i;
|
||
|
|
e = e % (4 * n);
|
||
|
|
float w = 1;
|
||
|
|
if (e > 2 * n) { e = 4 * n - e; }
|
||
|
|
if (e > n) { w = -1; e = 2 * n - e; }
|
||
|
|
assert(e <= n);
|
||
|
|
w *= c[e];
|
||
|
|
acc += w * data[j];
|
||
|
|
}
|
||
|
|
|
||
|
|
values[stride * i] = acc * scale[i > 0];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void dct(float values[], uniform int stride, uniform int n)
|
||
|
|
{
|
||
|
|
if (false) {}
|
||
|
|
else if (n == 8) dct_n(values, stride, 8);
|
||
|
|
else if (n == 6) dct_6(values, stride);
|
||
|
|
else if (n == 5) dct_n(values, stride, 5);
|
||
|
|
else if (n == 4) dct_4(values, stride);
|
||
|
|
else
|
||
|
|
{
|
||
|
|
assert(false);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void compute_dct_inplace(pixel_set block[], uniform int channels)
|
||
|
|
{
|
||
|
|
uniform static const int stride = 8;
|
||
|
|
uniform static const int pitch = 64;
|
||
|
|
|
||
|
|
for (uniform int p = 0; p < channels; p++)
|
||
|
|
{
|
||
|
|
for (uniform int y = 0; y < block->height; y++)
|
||
|
|
dct(&block->pixels[pitch * p + y * stride], 1, block->width);
|
||
|
|
|
||
|
|
for (uniform int x = 0; x < block->width; x++)
|
||
|
|
dct(&block->pixels[pitch * p + x], stride, block->height);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void compute_metrics(astc_rank_state state[])
|
||
|
|
{
|
||
|
|
float temp_pixels[256];
|
||
|
|
pixel_set _pset; varying pixel_set* uniform pset = &_pset;
|
||
|
|
pset->pixels = temp_pixels;
|
||
|
|
pset->width = state->block_width;
|
||
|
|
pset->height = state->block_height;
|
||
|
|
|
||
|
|
for (uniform int p = 0; p < 4; p++)
|
||
|
|
for (uniform int y = 0; y < state->block_height; y++)
|
||
|
|
for (uniform int x = 0; x < state->block_width; x++)
|
||
|
|
{
|
||
|
|
float value = get_pixel(state->pixels, p, x, y);
|
||
|
|
set_pixel(pset->pixels, p, x, y, value);
|
||
|
|
}
|
||
|
|
|
||
|
|
for (uniform int i = 0; i < 2; i++)
|
||
|
|
{
|
||
|
|
bool zero_based = (i == 1);
|
||
|
|
float endpoints[8];
|
||
|
|
compute_pca_endpoints(endpoints, pset, zero_based, 4);
|
||
|
|
|
||
|
|
float base[4], dir[4];
|
||
|
|
for (int p = 0; p < 4; p++) dir[p] = endpoints[p * 2 + 1] - endpoints[p * 2];
|
||
|
|
for (int p = 0; p < 4; p++) base[p] = endpoints[p * 2];
|
||
|
|
float sq_norm = dot4(dir, dir) + 0.00001;
|
||
|
|
|
||
|
|
float pca_error = 0;
|
||
|
|
float alpha_error = 0;
|
||
|
|
float pca_alpha_error = 0;
|
||
|
|
for (uniform int y = 0; y < state->block_height; y++)
|
||
|
|
for (uniform int x = 0; x < state->block_width; x++)
|
||
|
|
{
|
||
|
|
float pixel[4];
|
||
|
|
for (uniform int p = 0; p < 4; p++) pixel[p] = get_pixel(pset->pixels, p, x, y) - base[p];
|
||
|
|
float proj = dot4(pixel, dir) / sq_norm;
|
||
|
|
for (uniform int p = 0; p < 3; p++) pca_error += sq(get_pixel(pset->pixels, p, x, y) - (proj * dir[p] + base[p]));
|
||
|
|
pca_alpha_error += sq(get_pixel(pset->pixels, 3, x, y) - (proj * dir[3] + base[3]));
|
||
|
|
alpha_error += sq(get_pixel(pset->pixels, 3, x, y) - 255);
|
||
|
|
}
|
||
|
|
|
||
|
|
state->pca_error[i][0] = pca_error + pca_alpha_error;
|
||
|
|
state->alpha_error[i][0] = alpha_error - pca_alpha_error;
|
||
|
|
state->sq_norm[i][0] = sq_norm;
|
||
|
|
}
|
||
|
|
|
||
|
|
for (uniform int i = 0; i < 2; i++)
|
||
|
|
for (uniform int c = 1; c < 5; c++)
|
||
|
|
{
|
||
|
|
rotate_plane(pset, c - 1);
|
||
|
|
|
||
|
|
bool zero_based = (i == 1);
|
||
|
|
float endpoints[8];
|
||
|
|
compute_pca_endpoints(endpoints, pset, zero_based, 3);
|
||
|
|
|
||
|
|
float base[3], dir[3];
|
||
|
|
for (int p = 0; p < 3; p++) dir[p] = endpoints[p * 2 + 1] - endpoints[p * 2];
|
||
|
|
for (int p = 0; p < 3; p++) base[p] = endpoints[p * 2];
|
||
|
|
float sq_norm = dot3(dir, dir) + 0.00001;
|
||
|
|
|
||
|
|
float pca_error = 0;
|
||
|
|
float alpha_error = 0;
|
||
|
|
float pca_alpha_error = 0;
|
||
|
|
float ext[2] = { 1000, -1000 };
|
||
|
|
for (uniform int y = 0; y < state->block_height; y++)
|
||
|
|
for (uniform int x = 0; x < state->block_width; x++)
|
||
|
|
{
|
||
|
|
float pixel[3];
|
||
|
|
for (uniform int p = 0; p < 3; p++) pixel[p] = get_pixel(pset->pixels, p, x, y) - base[p];
|
||
|
|
float proj = dot3(pixel, dir) / sq_norm;
|
||
|
|
for (uniform int p = 0; p < 3; p++)
|
||
|
|
{
|
||
|
|
if (p == c - 1)
|
||
|
|
{
|
||
|
|
pca_alpha_error += sq(get_pixel(pset->pixels, p, x, y) - (proj * dir[p] + base[p]));
|
||
|
|
alpha_error += sq(get_pixel(pset->pixels, p, x, y) - 255);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
pca_error += sq(get_pixel(pset->pixels, p, x, y) - (proj * dir[p] + base[p]));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
float value = get_pixel(pset->pixels, 3, x, y);
|
||
|
|
ext[0] = min(ext[0], value);
|
||
|
|
ext[1] = max(ext[1], value);
|
||
|
|
}
|
||
|
|
|
||
|
|
state->pca_error[i][c] = pca_error + pca_alpha_error;
|
||
|
|
state->alpha_error[i][c] = alpha_error - pca_alpha_error;
|
||
|
|
state->sq_norm[i][c] = sq_norm + sq(ext[1] - ext[0]);
|
||
|
|
|
||
|
|
// rotate back
|
||
|
|
rotate_plane(pset, c - 1);
|
||
|
|
}
|
||
|
|
|
||
|
|
compute_dct_inplace(pset, 4);
|
||
|
|
|
||
|
|
for (uniform int h = 2; h <= state->block_height; h++)
|
||
|
|
for (uniform int w = 2; w <= state->block_width; w++)
|
||
|
|
{
|
||
|
|
uniform int stride = 8;
|
||
|
|
uniform int pitch = 64;
|
||
|
|
|
||
|
|
float sq_sum = 0;
|
||
|
|
|
||
|
|
for (uniform int y = 0; y < state->block_height; y++)
|
||
|
|
for (uniform int x = 0; x < state->block_width; x++)
|
||
|
|
{
|
||
|
|
if (y < h && x < w) continue;
|
||
|
|
|
||
|
|
for (uniform int p = 0; p < 4; p++)
|
||
|
|
sq_sum += sq(pset->pixels[pitch * p + stride * y + x]);
|
||
|
|
}
|
||
|
|
|
||
|
|
state->scale_error[h - 2][w - 2] = sq_sum;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
float estimate_error(astc_rank_state state[], uniform astc_mode mode[])
|
||
|
|
{
|
||
|
|
uniform int c = 0;
|
||
|
|
if (mode->dual_plane) c = 1 + mode->color_component_selector;
|
||
|
|
|
||
|
|
float scale_error = state->scale_error[mode->height - 2][mode->width - 2];
|
||
|
|
|
||
|
|
uniform bool zero_based = (mode->color_endpoint_modes[0] % 4) == 2;
|
||
|
|
float pca_error = state->pca_error[zero_based][c];
|
||
|
|
float sq_norm = state->sq_norm[zero_based][c];
|
||
|
|
|
||
|
|
if (mode->color_endpoint_modes[0] <= 8) pca_error += state->alpha_error[zero_based][c];
|
||
|
|
|
||
|
|
uniform float sq_rcp_w_levels = get_sq_rcp_levels(mode->weight_range);
|
||
|
|
uniform float sq_rcp_ep_levels = get_sq_rcp_levels(mode->endpoint_range);
|
||
|
|
float quant_error = 0;
|
||
|
|
|
||
|
|
quant_error += 2 * sq_norm * sq_rcp_w_levels;
|
||
|
|
quant_error += 9000 * (state->block_height * state->block_width) * sq_rcp_ep_levels;
|
||
|
|
|
||
|
|
float error = 0;
|
||
|
|
error += scale_error;
|
||
|
|
error += pca_error;
|
||
|
|
error += quant_error;
|
||
|
|
|
||
|
|
return error;
|
||
|
|
}
|
||
|
|
|
||
|
|
void insert_element(astc_rank_state state[], float error, uint32_t packed_mode, float threshold_error[])
|
||
|
|
{
|
||
|
|
float max_error = 0;
|
||
|
|
|
||
|
|
for (uniform int k = 0; k < state->fastSkipTreshold; k++)
|
||
|
|
{
|
||
|
|
if (state->best_scores[k] > error)
|
||
|
|
{
|
||
|
|
swap(state->best_scores[k], error);
|
||
|
|
swap(state->best_modes[k], packed_mode);
|
||
|
|
}
|
||
|
|
|
||
|
|
max_error = max(max_error, state->best_scores[k]);
|
||
|
|
}
|
||
|
|
|
||
|
|
*threshold_error = max_error;
|
||
|
|
}
|
||
|
|
|
||
|
|
uniform static const int packed_modes_count = 3334;
|
||
|
|
uniform static const uint32_t packed_modes[3334] =
|
||
|
|
{
|
||
|
|
0x0006D400, 0x0016D340, 0x0026D380, 0x0036CDC0, 0x00469400, 0x00569401, 0x00668702, 0x00769440,
|
||
|
|
0x00868D41, 0x00969480, 0x00A68D81, 0x00B693C0, 0x00C688C1, 0x00D4D400, 0x00E4D401, 0x00F4C702,
|
||
|
|
0x0104D440, 0x0114CD41, 0x0124D480, 0x0134CD81, 0x0144D3C0, 0x0154C8C1, 0x01667400, 0x01767401,
|
||
|
|
0x01867302, 0x01966803, 0x01A67440, 0x01B67341, 0x01C66B42, 0x01D66443, 0x01E67480, 0x01F67381,
|
||
|
|
0x02066B82, 0x02166483, 0x022674C0, 0x02366DC1, 0x024667C2, 0x0253D400, 0x0263D401, 0x0273D302,
|
||
|
|
0x0283C803, 0x0293D440, 0x02A3D341, 0x02B3CB42, 0x02C3C443, 0x02D3D480, 0x02E3D381, 0x02F3CB82,
|
||
|
|
0x0303C483, 0x0313D4C0, 0x0323CDC1, 0x0333C7C2, 0x03465400, 0x03565401, 0x03665402, 0x03765403,
|
||
|
|
0x03865004, 0x03964705, 0x03A65440, 0x03B65441, 0x03C65342, 0x03D64E43, 0x03E64944, 0x03F65480,
|
||
|
|
0x04065481, 0x04165382, 0x04264E83, 0x04364984, 0x044654C0, 0x045652C1, 0x04664DC2, 0x047649C3,
|
||
|
|
0x048646C4, 0x049E5400, 0x04AE5240, 0x04BE5280, 0x04CE4DC0, 0x04DE5410, 0x04EE5250, 0x04FE5290,
|
||
|
|
0x050E4DD0, 0x051E5420, 0x052E5260, 0x053E52A0, 0x054E4DE0, 0x055E52B0, 0x056E4DF0, 0x0572D400,
|
||
|
|
0x0582D401, 0x0592D402, 0x05A2D403, 0x05B2D004, 0x05C2C705, 0x05D2D440, 0x05E2D441, 0x05F2D342,
|
||
|
|
0x0602CE43, 0x0612C944, 0x0622D480, 0x0632D481, 0x0642D382, 0x0652CE83, 0x0662C984, 0x0672D4C0,
|
||
|
|
0x0682D2C1, 0x0692CDC2, 0x06A2C9C3, 0x06B2C6C4, 0x06CAD400, 0x06DAD240, 0x06EAD280, 0x06FACDC0,
|
||
|
|
0x070AD410, 0x071AD250, 0x072AD290, 0x073ACDD0, 0x074AD420, 0x075AD260, 0x076AD2A0, 0x077ACDE0,
|
||
|
|
0x078AD2B0, 0x079ACDF0, 0x07A63400, 0x07B63401, 0x07C63402, 0x07D63403, 0x07E63404, 0x07F63405,
|
||
|
|
0x08063306, 0x08162E07, 0x08262708, 0x08363440, 0x08463441, 0x08563442, 0x08663443, 0x08763444,
|
||
|
|
0x08862F45, 0x08962B46, 0x08A62847, 0x08B63480, 0x08C63481, 0x08D63482, 0x08E63483, 0x08F63484,
|
||
|
|
0x09062F85, 0x09162B86, 0x09262887, 0x093634C0, 0x094634C1, 0x095633C2, 0x096630C3, 0x09762EC4,
|
||
|
|
0x09862AC5, 0x099627C6, 0x09A625C7, 0x09BE3400, 0x09CE3401, 0x09DE2502, 0x09EE3440, 0x09FE2C41,
|
||
|
|
0x0A0E3480, 0x0A1E2C81, 0x0A2E33C0, 0x0A3E28C1, 0x0A4E3410, 0x0A5E3411, 0x0A6E2512, 0x0A7E3450,
|
||
|
|
0x0A8E2C51, 0x0A9E3490, 0x0AAE2C91, 0x0ABE33D0, 0x0ACE28D1, 0x0ADE3420, 0x0AEE3421, 0x0AFE2522,
|
||
|
|
0x0B0E3460, 0x0B1E2C61, 0x0B2E34A0, 0x0B3E2CA1, 0x0B4E33E0, 0x0B5E28E1, 0x0B6E34B0, 0x0B7E2CB1,
|
||
|
|
0x0B8E33F0, 0x0B9E28F1, 0x0BA1D400, 0x0BB1D401, 0x0BC1D402, 0x0BD1D403, 0x0BE1D404, 0x0BF1D405,
|
||
|
|
0x0C01D306, 0x0C11CE07, 0x0C21C708, 0x0C31D440, 0x0C41D441, 0x0C51D442, 0x0C61D443, 0x0C71D444,
|
||
|
|
0x0C81CF45, 0x0C91CB46, 0x0CA1C847, 0x0CB1D480, 0x0CC1D481, 0x0CD1D482, 0x0CE1D483, 0x0CF1D484,
|
||
|
|
0x0D01CF85, 0x0D11CB86, 0x0D21C887, 0x0D31D4C0, 0x0D41D4C1, 0x0D51D3C2, 0x0D61D0C3, 0x0D71CEC4,
|
||
|
|
0x0D81CAC5, 0x0D91C7C6, 0x0DA1C5C7, 0x0DB9D400, 0x0DC9D401, 0x0DD9C502, 0x0DE9D440, 0x0DF9CC41,
|
||
|
|
0x0E09D480, 0x0E19CC81, 0x0E29D3C0, 0x0E39C8C1, 0x0E49D410, 0x0E59D411, 0x0E69C512, 0x0E79D450,
|
||
|
|
0x0E89CC51, 0x0E99D490, 0x0EA9CC91, 0x0EB9D3D0, 0x0EC9C8D1, 0x0ED9D420, 0x0EE9D421, 0x0EF9C522,
|
||
|
|
0x0F09D460, 0x0F19CC61, 0x0F29D4A0, 0x0F39CCA1, 0x0F49D3E0, 0x0F59C8E1, 0x0F69D4B0, 0x0F79CCB1,
|
||
|
|
0x0F89D3F0, 0x0F99C8F1, 0x0FA61401, 0x0FB61402, 0x0FC61403, 0x0FD61404, 0x0FE61405, 0x0FF61406,
|
||
|
|
0x10061407, 0x10161408, 0x10261409, 0x1036140A, 0x1046130B, 0x10561441, 0x10661442, 0x10761443,
|
||
|
|
0x10861444, 0x10961445, 0x10A61446, 0x10B61447, 0x10C61348, 0x10D61049, 0x10E60E4A, 0x10F60B4B,
|
||
|
|
0x11061481, 0x11161482, 0x11261483, 0x11361484, 0x11461485, 0x11561486, 0x11661487, 0x11761388,
|
||
|
|
0x11861089, 0x11960E8A, 0x11A60B8B, 0x11B614C1, 0x11C614C2, 0x11D614C3, 0x11E614C4, 0x11F613C5,
|
||
|
|
0x120611C6, 0x121610C7, 0x12260DC8, 0x12360BC9, 0x12460ACA, 0x125607CB, 0x126E1400, 0x127E1401,
|
||
|
|
0x128E1402, 0x129E1403, 0x12AE0E04, 0x12BE0505, 0x12CE1440, 0x12DE1441, 0x12EE1242, 0x12FE0D43,
|
||
|
|
0x130E0844, 0x131E1480, 0x132E1481, 0x133E1282, 0x134E0D83, 0x135E0884, 0x136E14C0, 0x137E11C1,
|
||
|
|
0x138E0DC2, 0x139E08C3, 0x13AE05C4, 0x13BE1410, 0x13CE1411, 0x13DE1412, 0x13EE1413, 0x13FE0E14,
|
||
|
|
0x140E0515, 0x141E1450, 0x142E1451, 0x143E1252, 0x144E0D53, 0x145E0854, 0x146E1490, 0x147E1491,
|
||
|
|
0x148E1292, 0x149E0D93, 0x14AE0894, 0x14BE14D0, 0x14CE11D1, 0x14DE0DD2, 0x14EE08D3, 0x14FE05D4,
|
||
|
|
0x150E1420, 0x151E1421, 0x152E1422, 0x153E1423, 0x154E0E24, 0x155E0525, 0x156E1460, 0x157E1461,
|
||
|
|
0x158E1262, 0x159E0D63, 0x15AE0864, 0x15BE14A0, 0x15CE14A1, 0x15DE12A2, 0x15EE0DA3, 0x15FE08A4,
|
||
|
|
0x160E14E0, 0x161E11E1, 0x162E0DE2, 0x163E08E3, 0x164E05E4, 0x165E14B0, 0x166E14B1, 0x167E12B2,
|
||
|
|
0x168E0DB3, 0x169E08B4, 0x16AE14F0, 0x16BE11F1, 0x16CE0DF2, 0x16DE08F3, 0x16EE05F4, 0x16F0D401,
|
||
|
|
0x1700D402, 0x1710D403, 0x1720D404, 0x1730D405, 0x1740D406, 0x1750D407, 0x1760D408, 0x1770D409,
|
||
|
|
0x1780D40A, 0x1790D30B, 0x17A0D441, 0x17B0D442, 0x17C0D443, 0x17D0D444, 0x17E0D445, 0x17F0D446,
|
||
|
|
0x1800D447, 0x1810D348, 0x1820D049, 0x1830CE4A, 0x1840CB4B, 0x1850D481, 0x1860D482, 0x1870D483,
|
||
|
|
0x1880D484, 0x1890D485, 0x18A0D486, 0x18B0D487, 0x18C0D388, 0x18D0D089, 0x18E0CE8A, 0x18F0CB8B,
|
||
|
|
0x1900D4C1, 0x1910D4C2, 0x1920D4C3, 0x1930D4C4, 0x1940D3C5, 0x1950D1C6, 0x1960D0C7, 0x1970CDC8,
|
||
|
|
0x1980CBC9, 0x1990CACA, 0x19A0C7CB, 0x19B8D400, 0x19C8D401, 0x19D8D402, 0x19E8D403, 0x19F8CE04,
|
||
|
|
0x1A08C505, 0x1A18D440, 0x1A28D441, 0x1A38D242, 0x1A48CD43, 0x1A58C844, 0x1A68D480, 0x1A78D481,
|
||
|
|
0x1A88D282, 0x1A98CD83, 0x1AA8C884, 0x1AB8D4C0, 0x1AC8D1C1, 0x1AD8CDC2, 0x1AE8C8C3, 0x1AF8C5C4,
|
||
|
|
0x1B08D410, 0x1B18D411, 0x1B28D412, 0x1B38D413, 0x1B48CE14, 0x1B58C515, 0x1B68D450, 0x1B78D451,
|
||
|
|
0x1B88D252, 0x1B98CD53, 0x1BA8C854, 0x1BB8D490, 0x1BC8D491, 0x1BD8D292, 0x1BE8CD93, 0x1BF8C894,
|
||
|
|
0x1C08D4D0, 0x1C18D1D1, 0x1C28CDD2, 0x1C38C8D3, 0x1C48C5D4, 0x1C58D420, 0x1C68D421, 0x1C78D422,
|
||
|
|
0x1C88D423, 0x1C98CE24, 0x1CA8C525, 0x1CB8D460, 0x1CC8D461, 0x1CD8D262, 0x1CE8CD63, 0x1CF8C864,
|
||
|
|
0x1D08D4A0, 0x1D18D4A1, 0x1D28D2A2, 0x1D38CDA3, 0x1D48C8A4, 0x1D58D4E0, 0x1D68D1E1, 0x1D78CDE2,
|
||
|
|
0x1D88C8E3, 0x1D98C5E4, 0x1DA8D4B0, 0x1DB8D4B1, 0x1DC8D2B2, 0x1DD8CDB3, 0x1DE8C8B4, 0x1DF8D4F0,
|
||
|
|
0x1E08D1F1, 0x1E18CDF2, 0x1E28C8F3, 0x1E38C5F4, 0x1E449400, 0x1E549401, 0x1E649402, 0x1E749003,
|
||
|
|
0x1E848804, 0x1E949440, 0x1EA49441, 0x1EB48F42, 0x1EC48943, 0x1ED48444, 0x1EE49480, 0x1EF49481,
|
||
|
|
0x1F048F82, 0x1F148983, 0x1F248484, 0x1F3494C0, 0x1F4490C1, 0x1F548AC2, 0x1F6486C3, 0x1F747400,
|
||
|
|
0x1F847401, 0x1F947402, 0x1FA47403, 0x1FB47404, 0x1FC46B05, 0x1FD47440, 0x1FE47441, 0x1FF47442,
|
||
|
|
0x20047043, 0x20146C44, 0x20246645, 0x20347480, 0x20447481, 0x20547482, 0x20647083, 0x20746C84,
|
||
|
|
0x20846685, 0x209474C0, 0x20A473C1, 0x20B46FC2, 0x20C46BC3, 0x20D468C4, 0x20E464C5, 0x20FC7400,
|
||
|
|
0x210C6501, 0x211C7440, 0x212C7480, 0x213C6EC0, 0x214C7410, 0x215C6511, 0x216C7450, 0x217C7490,
|
||
|
|
0x218C6ED0, 0x219C7420, 0x21AC6521, 0x21BC7460, 0x21CC74A0, 0x21DC6EE0, 0x21EC74B0, 0x21FC6EF0,
|
||
|
|
0x22039400, 0x22139401, 0x22239402, 0x22339403, 0x22439404, 0x22538B05, 0x22639440, 0x22739441,
|
||
|
|
0x22839442, 0x22939043, 0x22A38C44, 0x22B38645, 0x22C39480, 0x22D39481, 0x22E39482, 0x22F39083,
|
||
|
|
0x23038C84, 0x23138685, 0x232394C0, 0x233393C1, 0x23438FC2, 0x23538BC3, 0x236388C4, 0x237384C5,
|
||
|
|
0x238B9400, 0x239B8501, 0x23AB9440, 0x23BB9480, 0x23CB8EC0, 0x23DB9410, 0x23EB8511, 0x23FB9450,
|
||
|
|
0x240B9490, 0x241B8ED0, 0x242B9420, 0x243B8521, 0x244B9460, 0x245B94A0, 0x246B8EE0, 0x247B94B0,
|
||
|
|
0x248B8EF0, 0x24937400, 0x24A37401, 0x24B37402, 0x24C37403, 0x24D37404, 0x24E37405, 0x24F37006,
|
||
|
|
0x25036B07, 0x25137440, 0x25237441, 0x25337442, 0x25437443, 0x25537344, 0x25636E45, 0x25736946,
|
||
|
|
0x25836647, 0x25937480, 0x25A37481, 0x25B37482, 0x25C37483, 0x25D37384, 0x25E36E85, 0x25F36986,
|
||
|
|
0x26036687, 0x261374C0, 0x262374C1, 0x263373C2, 0x26436FC3, 0x26536DC4, 0x266369C5, 0x267366C6,
|
||
|
|
0x268364C7, 0x269B7400, 0x26AB7101, 0x26BB7440, 0x26CB6A41, 0x26DB7480, 0x26EB6A81, 0x26FB72C0,
|
||
|
|
0x270B67C1, 0x271B7410, 0x272B7111, 0x273B7450, 0x274B6A51, 0x275B7490, 0x276B6A91, 0x277B72D0,
|
||
|
|
0x278B67D1, 0x279B7420, 0x27AB7121, 0x27BB7460, 0x27CB6A61, 0x27DB74A0, 0x27EB6AA1, 0x27FB72E0,
|
||
|
|
0x280B67E1, 0x281B74B0, 0x282B6AB1, 0x283B72F0, 0x284B67F1, 0x28545400, 0x28645401, 0x28745402,
|
||
|
|
0x28845403, 0x28945404, 0x28A45405, 0x28B45306, 0x28C44E07, 0x28D44708, 0x28E45440, 0x28F45441,
|
||
|
|
0x29045442, 0x29145443, 0x29245444, 0x29344F45, 0x29444B46, 0x29544847, 0x29645480, 0x29745481,
|
||
|
|
0x29845482, 0x29945483, 0x29A45484, 0x29B44F85, 0x29C44B86, 0x29D44887, 0x29E454C0, 0x29F454C1,
|
||
|
|
0x2A0453C2, 0x2A1450C3, 0x2A244EC4, 0x2A344AC5, 0x2A4447C6, 0x2A5445C7, 0x2A6C5400, 0x2A7C5401,
|
||
|
|
0x2A8C4502, 0x2A9C5440, 0x2AAC4C41, 0x2ABC5480, 0x2ACC4C81, 0x2ADC53C0, 0x2AEC48C1, 0x2AFC5410,
|
||
|
|
0x2B0C5411, 0x2B1C4512, 0x2B2C5450, 0x2B3C4C51, 0x2B4C5490, 0x2B5C4C91, 0x2B6C53D0, 0x2B7C48D1,
|
||
|
|
0x2B8C5420, 0x2B9C5421, 0x2BAC4522, 0x2BBC5460, 0x2BCC4C61, 0x2BDC54A0, 0x2BEC4CA1, 0x2BFC53E0,
|
||
|
|
0x2C0C48E1, 0x2C1C54B0, 0x2C2C4CB1, 0x2C3C53F0, 0x2C4C48F1, 0x2C529400, 0x2C629401, 0x2C729402,
|
||
|
|
0x2C829403, 0x2C929404, 0x2CA29405, 0x2CB29306, 0x2CC28E07, 0x2CD28708, 0x2CE29440, 0x2CF29441,
|
||
|
|
0x2D029442, 0x2D129443, 0x2D229444, 0x2D328F45, 0x2D428B46, 0x2D528847, 0x2D629480, 0x2D729481,
|
||
|
|
0x2D829482, 0x2D929483, 0x2DA29484, 0x2DB28F85, 0x2DC28B86, 0x2DD28887, 0x2DE294C0, 0x2DF294C1,
|
||
|
|
0x2E0293C2, 0x2E1290C3, 0x2E228EC4, 0x2E328AC5, 0x2E4287C6, 0x2E5285C7, 0x2E6A9400, 0x2E7A9401,
|
||
|
|
0x2E8A8502, 0x2E9A9440, 0x2EAA8C41, 0x2EBA9480, 0x2ECA8C81, 0x2EDA93C0, 0x2EEA88C1, 0x2EFA9410,
|
||
|
|
0x2F0A9411, 0x2F1A8512, 0x2F2A9450, 0x2F3A8C51, 0x2F4A9490, 0x2F5A8C91, 0x2F6A93D0, 0x2F7A88D1,
|
||
|
|
0x2F8A9420, 0x2F9A9421, 0x2FAA8522, 0x2FBA9460, 0x2FCA8C61, 0x2FDA94A0, 0x2FEA8CA1, 0x2FFA93E0,
|
||
|
|
0x300A88E1, 0x301A94B0, 0x302A8CB1, 0x303A93F0, 0x304A88F1, 0x30535401, 0x30635402, 0x30735403,
|
||
|
|
0x30835404, 0x30935405, 0x30A35406, 0x30B35407, 0x30C35308, 0x30D34E09, 0x30E34A0A, 0x30F35441,
|
||
|
|
0x31035442, 0x31135443, 0x31235444, 0x31335445, 0x31435246, 0x31534F47, 0x31634B48, 0x31734849,
|
||
|
|
0x3183454A, 0x31935481, 0x31A35482, 0x31B35483, 0x31C35484, 0x31D35485, 0x31E35286, 0x31F34F87,
|
||
|
|
0x32034B88, 0x32134889, 0x3223458A, 0x323354C1, 0x324354C2, 0x325354C3, 0x326352C4, 0x32734FC5,
|
||
|
|
0x32834CC6, 0x32934AC7, 0x32A347C8, 0x32B345C9, 0x32CB5400, 0x32DB5401, 0x32EB5102, 0x32FB4703,
|
||
|
|
0x330B5440, 0x331B5241, 0x332B4A42, 0x333B5480, 0x334B5281, 0x335B4A82, 0x336B54C0, 0x337B4DC1,
|
||
|
|
0x338B47C2, 0x339B5410, 0x33AB5411, 0x33BB5112, 0x33CB4713, 0x33DB5450, 0x33EB5251, 0x33FB4A52,
|
||
|
|
0x340B5490, 0x341B5291, 0x342B4A92, 0x343B54D0, 0x344B4DD1, 0x345B47D2, 0x346B5420, 0x347B5421,
|
||
|
|
0x348B5122, 0x349B4723, 0x34AB5460, 0x34BB5261, 0x34CB4A62, 0x34DB54A0, 0x34EB52A1, 0x34FB4AA2,
|
||
|
|
0x350B54E0, 0x351B4DE1, 0x352B47E2, 0x353B54B0, 0x354B52B1, 0x355B4AB2, 0x356B54F0, 0x357B4DF1,
|
||
|
|
0x358B47F2, 0x35927401, 0x35A27402, 0x35B27403, 0x35C27404, 0x35D27405, 0x35E27406, 0x35F27407,
|
||
|
|
0x36027308, 0x36126E09, 0x36226A0A, 0x36327441, 0x36427442, 0x36527443, 0x36627444, 0x36727445,
|
||
|
|
0x36827246, 0x36926F47, 0x36A26B48, 0x36B26849, 0x36C2654A, 0x36D27481, 0x36E27482, 0x36F27483,
|
||
|
|
0x37027484, 0x37127485, 0x37227286, 0x37326F87, 0x37426B88, 0x37526889, 0x3762658A, 0x377274C1,
|
||
|
|
0x378274C2, 0x379274C3, 0x37A272C4, 0x37B26FC5, 0x37C26CC6, 0x37D26AC7, 0x37E267C8, 0x37F265C9,
|
||
|
|
0x380A7400, 0x381A7401, 0x382A7102, 0x383A6703, 0x384A7440, 0x385A7241, 0x386A6A42, 0x387A7480,
|
||
|
|
0x388A7281, 0x389A6A82, 0x38AA74C0, 0x38BA6DC1, 0x38CA67C2, 0x38DA7410, 0x38EA7411, 0x38FA7112,
|
||
|
|
0x390A6713, 0x391A7450, 0x392A7251, 0x393A6A52, 0x394A7490, 0x395A7291, 0x396A6A92, 0x397A74D0,
|
||
|
|
0x398A6DD1, 0x399A67D2, 0x39AA7420, 0x39BA7421, 0x39CA7122, 0x39DA6723, 0x39EA7460, 0x39FA7261,
|
||
|
|
0x3A0A6A62, 0x3A1A74A0, 0x3A2A72A1, 0x3A3A6AA2, 0x3A4A74E0, 0x3A5A6DE1, 0x3A6A67E2, 0x3A7A74B0,
|
||
|
|
0x3A8A72B1, 0x3A9A6AB2, 0x3AAA74F0, 0x3ABA6DF1, 0x3ACA67F2, 0x3AD25401, 0x3AE25402, 0x3AF25403,
|
||
|
|
0x3B025404, 0x3B125405, 0x3B225406, 0x3B325407, 0x3B425408, 0x3B525409, 0x3B62540A, 0x3B72530B,
|
||
|
|
0x3B825441, 0x3B925442, 0x3BA25443, 0x3BB25444, 0x3BC25445, 0x3BD25446, 0x3BE25447, 0x3BF25348,
|
||
|
|
0x3C025049, 0x3C124E4A, 0x3C224B4B, 0x3C325481, 0x3C425482, 0x3C525483, 0x3C625484, 0x3C725485,
|
||
|
|
0x3C825486, 0x3C925487, 0x3CA25388, 0x3CB25089, 0x3CC24E8A, 0x3CD24B8B, 0x3CE254C1, 0x3CF254C2,
|
||
|
|
0x3D0254C3, 0x3D1254C4, 0x3D2253C5, 0x3D3251C6, 0x3D4250C7, 0x3D524DC8, 0x3D624BC9, 0x3D724ACA,
|
||
|
|
0x3D8247CB, 0x3D9A5400, 0x3DAA5401, 0x3DBA5402, 0x3DCA5403, 0x3DDA4E04, 0x3DEA4505, 0x3DFA5440,
|
||
|
|
0x3E0A5441, 0x3E1A5242, 0x3E2A4D43, 0x3E3A4844, 0x3E4A5480, 0x3E5A5481, 0x3E6A5282, 0x3E7A4D83,
|
||
|
|
0x3E8A4884, 0x3E9A54C0, 0x3EAA51C1, 0x3EBA4DC2, 0x3ECA48C3, 0x3EDA45C4, 0x3EEA5410, 0x3EFA5411,
|
||
|
|
0x3F0A5412, 0x3F1A5413, 0x3F2A4E14, 0x3F3A4515, 0x3F4A5450, 0x3F5A5451, 0x3F6A5252, 0x3F7A4D53,
|
||
|
|
0x3F8A4854, 0x3F9A5490, 0x3FAA5491, 0x3FBA5292, 0x3FCA4D93, 0x3FDA4894, 0x3FEA54D0, 0x3FFA51D1,
|
||
|
|
0x400A4DD2, 0x401A48D3, 0x402A45D4, 0x403A5420, 0x404A5421, 0x405A5422, 0x406A5423, 0x407A4E24,
|
||
|
|
0x408A4525, 0x409A5460, 0x40AA5461, 0x40BA5262, 0x40CA4D63, 0x40DA4864, 0x40EA54A0, 0x40FA54A1,
|
||
|
|
0x410A52A2, 0x411A4DA3, 0x412A48A4, 0x413A54E0, 0x414A51E1, 0x415A4DE2, 0x416A48E3, 0x417A45E4,
|
||
|
|
0x418A54B0, 0x419A54B1, 0x41AA52B2, 0x41BA4DB3, 0x41CA48B4, 0x41DA54F0, 0x41EA51F1, 0x41FA4DF2,
|
||
|
|
0x420A48F3, 0x421A45F4, 0x42243401, 0x42343402, 0x42443403, 0x42543404, 0x42643405, 0x42743406,
|
||
|
|
0x42843407, 0x42943408, 0x42A43409, 0x42B4310A, 0x42C42B0B, 0x42D43441, 0x42E43442, 0x42F43443,
|
||
|
|
0x43043444, 0x43143445, 0x43243446, 0x43343347, 0x43442F48, 0x43542C49, 0x43642A4A, 0x4374264B,
|
||
|
|
0x43843481, 0x43943482, 0x43A43483, 0x43B43484, 0x43C43485, 0x43D43486, 0x43E43387, 0x43F42F88,
|
||
|
|
0x44042C89, 0x44142A8A, 0x4424268B, 0x443434C1, 0x444434C2, 0x445434C3, 0x446434C4, 0x447431C5,
|
||
|
|
0x44842FC6, 0x44942DC7, 0x44A42AC8, 0x44B428C9, 0x44C426CA, 0x44D424CB, 0x44EC3400, 0x44FC3401,
|
||
|
|
0x450C3402, 0x451C2E03, 0x452C2704, 0x453C3440, 0x454C3441, 0x455C2E42, 0x456C2843, 0x457C3480,
|
||
|
|
0x458C3481, 0x459C2E82, 0x45AC2883, 0x45BC34C0, 0x45CC2FC1, 0x45DC2AC2, 0x45EC25C3, 0x45FC3410,
|
||
|
|
0x460C3411, 0x461C3412, 0x462C2E13, 0x463C2714, 0x464C3450, 0x465C3451, 0x466C2E52, 0x467C2853,
|
||
|
|
0x468C3490, 0x469C3491, 0x46AC2E92, 0x46BC2893, 0x46CC34D0, 0x46DC2FD1, 0x46EC2AD2, 0x46FC25D3,
|
||
|
|
0x470C3420, 0x471C3421, 0x472C3422, 0x473C2E23, 0x474C2724, 0x475C3460, 0x476C3461, 0x477C2E62,
|
||
|
|
0x478C2863, 0x479C34A0, 0x47AC34A1, 0x47BC2EA2, 0x47CC28A3, 0x47DC34E0, 0x47EC2FE1, 0x47FC2AE2,
|
||
|
|
0x480C25E3, 0x481C34B0, 0x482C34B1, 0x483C2EB2, 0x484C28B3, 0x485C34F0, 0x486C2FF1, 0x487C2AF2,
|
||
|
|
0x488C25F3, 0x48919401, 0x48A19402, 0x48B19403, 0x48C19404, 0x48D19405, 0x48E19406, 0x48F19407,
|
||
|
|
0x49019408, 0x49119409, 0x4921910A, 0x49318B0B, 0x49419441, 0x49519442, 0x49619443, 0x49719444,
|
||
|
|
0x49819445, 0x49919446, 0x49A19347, 0x49B18F48, 0x49C18C49, 0x49D18A4A, 0x49E1864B, 0x49F19481,
|
||
|
|
0x4A019482, 0x4A119483, 0x4A219484, 0x4A319485, 0x4A419486, 0x4A519387, 0x4A618F88, 0x4A718C89,
|
||
|
|
0x4A818A8A, 0x4A91868B, 0x4AA194C1, 0x4AB194C2, 0x4AC194C3, 0x4AD194C4, 0x4AE191C5, 0x4AF18FC6,
|
||
|
|
0x4B018DC7, 0x4B118AC8, 0x4B2188C9, 0x4B3186CA, 0x4B4184CB, 0x4B599400, 0x4B699401, 0x4B799402,
|
||
|
|
0x4B898E03, 0x4B998704, 0x4BA99440, 0x4BB99441, 0x4BC98E42, 0x4BD98843, 0x4BE99480, 0x4BF99481,
|
||
|
|
0x4C098E82, 0x4C198883, 0x4C2994C0, 0x4C398FC1, 0x4C498AC2, 0x4C5985C3, 0x4C699410, 0x4C799411,
|
||
|
|
0x4C899412, 0x4C998E13, 0x4CA98714, 0x4CB99450, 0x4CC99451, 0x4CD98E52, 0x4CE98853, 0x4CF99490,
|
||
|
|
0x4D099491, 0x4D198E92, 0x4D298893, 0x4D3994D0, 0x4D498FD1, 0x4D598AD2, 0x4D6985D3, 0x4D799420,
|
||
|
|
0x4D899421, 0x4D999422, 0x4DA98E23, 0x4DB98724, 0x4DC99460, 0x4DD99461, 0x4DE98E62, 0x4DF98863,
|
||
|
|
0x4E0994A0, 0x4E1994A1, 0x4E298EA2, 0x4E3988A3, 0x4E4994E0, 0x4E598FE1, 0x4E698AE2, 0x4E7985E3,
|
||
|
|
0x4E8994B0, 0x4E9994B1, 0x4EA98EB2, 0x4EB988B3, 0x4EC994F0, 0x4ED98FF1, 0x4EE98AF2, 0x4EF985F3,
|
||
|
|
0x4F033401, 0x4F133402, 0x4F233403, 0x4F333404, 0x4F433405, 0x4F533406, 0x4F633407, 0x4F733408,
|
||
|
|
0x4F833409, 0x4F93340A, 0x4FA3340B, 0x4FB33441, 0x4FC33442, 0x4FD33443, 0x4FE33444, 0x4FF33445,
|
||
|
|
0x50033446, 0x50133447, 0x50233448, 0x50333349, 0x5043314A, 0x50532E4B, 0x50633481, 0x50733482,
|
||
|
|
0x50833483, 0x50933484, 0x50A33485, 0x50B33486, 0x50C33487, 0x50D33488, 0x50E33389, 0x50F3318A,
|
||
|
|
0x51032E8B, 0x511334C1, 0x512334C2, 0x513334C3, 0x514334C4, 0x515334C5, 0x516333C6, 0x517331C7,
|
||
|
|
0x51832FC8, 0x51932DC9, 0x51A32BCA, 0x51B329CB, 0x51CB3400, 0x51DB3401, 0x51EB3402, 0x51FB3403,
|
||
|
|
0x520B3304, 0x521B2A05, 0x522B3440, 0x523B3441, 0x524B3442, 0x525B2F43, 0x526B2B44, 0x527B2545,
|
||
|
|
0x528B3480, 0x529B3481, 0x52AB3482, 0x52BB2F83, 0x52CB2B84, 0x52DB2585, 0x52EB34C0, 0x52FB33C1,
|
||
|
|
0x530B2EC2, 0x531B2AC3, 0x532B27C4, 0x533B3410, 0x534B3411, 0x535B3412, 0x536B3413, 0x537B3314,
|
||
|
|
0x538B2A15, 0x539B3450, 0x53AB3451, 0x53BB3452, 0x53CB2F53, 0x53DB2B54, 0x53EB2555, 0x53FB3490,
|
||
|
|
0x540B3491, 0x541B3492, 0x542B2F93, 0x543B2B94, 0x544B2595, 0x545B34D0, 0x546B33D1, 0x547B2ED2,
|
||
|
|
0x548B2AD3, 0x549B27D4, 0x54AB3420, 0x54BB3421, 0x54CB3422, 0x54DB3423, 0x54EB3324, 0x54FB2A25,
|
||
|
|
0x550B3460, 0x551B3461, 0x552B3462, 0x553B2F63, 0x554B2B64, 0x555B2565, 0x556B34A0, 0x557B34A1,
|
||
|
|
0x558B34A2, 0x559B2FA3, 0x55AB2BA4, 0x55BB25A5, 0x55CB34E0, 0x55DB33E1, 0x55EB2EE2, 0x55FB2AE3,
|
||
|
|
0x560B27E4, 0x561B34B0, 0x562B34B1, 0x563B34B2, 0x564B2FB3, 0x565B2BB4, 0x566B25B5, 0x567B34F0,
|
||
|
|
0x568B33F1, 0x569B2EF2, 0x56AB2AF3, 0x56BB27F4, 0x56C17401, 0x56D17402, 0x56E17403, 0x56F17404,
|
||
|
|
0x57017405, 0x57117406, 0x57217407, 0x57317408, 0x57417409, 0x5751740A, 0x5761740B, 0x57717441,
|
||
|
|
0x57817442, 0x57917443, 0x57A17444, 0x57B17445, 0x57C17446, 0x57D17447, 0x57E17448, 0x57F17349,
|
||
|
|
0x5801714A, 0x58116E4B, 0x58217481, 0x58317482, 0x58417483, 0x58517484, 0x58617485, 0x58717486,
|
||
|
|
0x58817487, 0x58917488, 0x58A17389, 0x58B1718A, 0x58C16E8B, 0x58D174C1, 0x58E174C2, 0x58F174C3,
|
||
|
|
0x590174C4, 0x591174C5, 0x592173C6, 0x593171C7, 0x59416FC8, 0x59516DC9, 0x59616BCA, 0x597169CB,
|
||
|
|
0x59897400, 0x59997401, 0x59A97402, 0x59B97403, 0x59C97304, 0x59D96A05, 0x59E97440, 0x59F97441,
|
||
|
|
0x5A097442, 0x5A196F43, 0x5A296B44, 0x5A396545, 0x5A497480, 0x5A597481, 0x5A697482, 0x5A796F83,
|
||
|
|
0x5A896B84, 0x5A996585, 0x5AA974C0, 0x5AB973C1, 0x5AC96EC2, 0x5AD96AC3, 0x5AE967C4, 0x5AF97410,
|
||
|
|
0x5B097411, 0x5B197412, 0x5B297413, 0x5B397314, 0x5B496A15, 0x5B597450, 0x5B697451, 0x5B797452,
|
||
|
|
0x5B896F53, 0x5B996B54, 0x5BA96555, 0x5BB97490, 0x5BC97491, 0x5BD97492, 0x5BE96F93, 0x5BF96B94,
|
||
|
|
0x5C096595, 0x5C1974D0, 0x5C2973D1, 0x5C396ED2, 0x5C496AD3, 0x5C5967D4, 0x5C697420, 0x5C797421,
|
||
|
|
0x5C897422, 0x5C997423, 0x5CA97324, 0x5CB96A25, 0x5CC97460, 0x5CD97461, 0x5CE97462, 0x5CF96F63,
|
||
|
|
0x5D096B64, 0x5D196565, 0x5D2974A0, 0x5D3974A1, 0x5D4974A2, 0x5D596FA3, 0x5D696BA4, 0x5D7965A5,
|
||
|
|
0x5D8974E0, 0x5D9973E1, 0x5DA96EE2, 0x5DB96AE3, 0x5DC967E4, 0x5DD974B0, 0x5DE974B1, 0x5DF974B2,
|
||
|
|
0x5E096FB3, 0x5E196BB4, 0x5E2965B5, 0x5E3974F0, 0x5E4973F1, 0x5E596EF2, 0x5E696AF3, 0x5E7967F4,
|
||
|
|
0x5E823402, 0x5E923403, 0x5EA23404, 0x5EB23405, 0x5EC23406, 0x5ED23407, 0x5EE23408, 0x5EF23409,
|
||
|
|
0x5F02340A, 0x5F12340B, 0x5F223442, 0x5F323443, 0x5F423444, 0x5F523445, 0x5F623446, 0x5F723447,
|
||
|
|
0x5F823448, 0x5F923449, 0x5FA2344A, 0x5FB2344B, 0x5FC23482, 0x5FD23483, 0x5FE23484, 0x5FF23485,
|
||
|
|
0x60023486, 0x60123487, 0x60223488, 0x60323489, 0x6042348A, 0x6052348B, 0x606234C2, 0x607234C3,
|
||
|
|
0x608234C4, 0x609234C5, 0x60A234C6, 0x60B234C7, 0x60C233C8, 0x60D232C9, 0x60E230CA, 0x60F22FCB,
|
||
|
|
0x610A3400, 0x611A3401, 0x612A3402, 0x613A3403, 0x614A3404, 0x615A3405, 0x616A3106, 0x617A2C07,
|
||
|
|
0x618A2508, 0x619A3440, 0x61AA3441, 0x61BA3442, 0x61CA3443, 0x61DA3344, 0x61EA2E45, 0x61FA2A46,
|
||
|
|
0x620A2747, 0x621A3480, 0x622A3481, 0x623A3482, 0x624A3483, 0x625A3384, 0x626A2E85, 0x627A2A86,
|
||
|
|
0x628A2787, 0x629A34C0, 0x62AA34C1, 0x62BA33C2, 0x62CA30C3, 0x62DA2DC4, 0x62EA2AC5, 0x62FA27C6,
|
||
|
|
0x630A24C7, 0x631A3410, 0x632A3411, 0x633A3412, 0x634A3413, 0x635A3414, 0x636A3415, 0x637A3116,
|
||
|
|
0x638A2C17, 0x639A2518, 0x63AA3450, 0x63BA3451, 0x63CA3452, 0x63DA3453, 0x63EA3354, 0x63FA2E55,
|
||
|
|
0x640A2A56, 0x641A2757, 0x642A3490, 0x643A3491, 0x644A3492, 0x645A3493, 0x646A3394, 0x647A2E95,
|
||
|
|
0x648A2A96, 0x649A2797, 0x64AA34D0, 0x64BA34D1, 0x64CA33D2, 0x64DA30D3, 0x64EA2DD4, 0x64FA2AD5,
|
||
|
|
0x650A27D6, 0x651A24D7, 0x652A3420, 0x653A3421, 0x654A3422, 0x655A3423, 0x656A3424, 0x657A3425,
|
||
|
|
0x658A3126, 0x659A2C27, 0x65AA2528, 0x65BA3460, 0x65CA3461, 0x65DA3462, 0x65EA3463, 0x65FA3364,
|
||
|
|
0x660A2E65, 0x661A2A66, 0x662A2767, 0x663A34A0, 0x664A34A1, 0x665A34A2, 0x666A34A3, 0x667A33A4,
|
||
|
|
0x668A2EA5, 0x669A2AA6, 0x66AA27A7, 0x66BA34E0, 0x66CA34E1, 0x66DA33E2, 0x66EA30E3, 0x66FA2DE4,
|
||
|
|
0x670A2AE5, 0x671A27E6, 0x672A24E7, 0x673A34B0, 0x674A34B1, 0x675A34B2, 0x676A34B3, 0x677A33B4,
|
||
|
|
0x678A2EB5, 0x679A2AB6, 0x67AA27B7, 0x67BA34F0, 0x67CA34F1, 0x67DA33F2, 0x67EA30F3, 0x67FA2DF4,
|
||
|
|
0x680A2AF5, 0x681A27F6, 0x682A24F7, 0x68315402, 0x68415403, 0x68515404, 0x68615405, 0x68715406,
|
||
|
|
0x68815407, 0x68915408, 0x68A15409, 0x68B1540A, 0x68C1540B, 0x68D15442, 0x68E15443, 0x68F15444,
|
||
|
|
0x69015445, 0x69115446, 0x69215447, 0x69315448, 0x69415449, 0x6951544A, 0x6961544B, 0x69715482,
|
||
|
|
0x69815483, 0x69915484, 0x69A15485, 0x69B15486, 0x69C15487, 0x69D15488, 0x69E15489, 0x69F1548A,
|
||
|
|
0x6A01548B, 0x6A1154C2, 0x6A2154C3, 0x6A3154C4, 0x6A4154C5, 0x6A5154C6, 0x6A6154C7, 0x6A7153C8,
|
||
|
|
0x6A8152C9, 0x6A9150CA, 0x6AA14FCB, 0x6AB95400, 0x6AC95401, 0x6AD95402, 0x6AE95403, 0x6AF95404,
|
||
|
|
0x6B095405, 0x6B195106, 0x6B294C07, 0x6B394508, 0x6B495440, 0x6B595441, 0x6B695442, 0x6B795443,
|
||
|
|
0x6B895344, 0x6B994E45, 0x6BA94A46, 0x6BB94747, 0x6BC95480, 0x6BD95481, 0x6BE95482, 0x6BF95483,
|
||
|
|
0x6C095384, 0x6C194E85, 0x6C294A86, 0x6C394787, 0x6C4954C0, 0x6C5954C1, 0x6C6953C2, 0x6C7950C3,
|
||
|
|
0x6C894DC4, 0x6C994AC5, 0x6CA947C6, 0x6CB944C7, 0x6CC95410, 0x6CD95411, 0x6CE95412, 0x6CF95413,
|
||
|
|
0x6D095414, 0x6D195415, 0x6D295116, 0x6D394C17, 0x6D494518, 0x6D595450, 0x6D695451, 0x6D795452,
|
||
|
|
0x6D895453, 0x6D995354, 0x6DA94E55, 0x6DB94A56, 0x6DC94757, 0x6DD95490, 0x6DE95491, 0x6DF95492,
|
||
|
|
0x6E095493, 0x6E195394, 0x6E294E95, 0x6E394A96, 0x6E494797, 0x6E5954D0, 0x6E6954D1, 0x6E7953D2,
|
||
|
|
0x6E8950D3, 0x6E994DD4, 0x6EA94AD5, 0x6EB947D6, 0x6EC944D7, 0x6ED95420, 0x6EE95421, 0x6EF95422,
|
||
|
|
0x6F095423, 0x6F195424, 0x6F295425, 0x6F395126, 0x6F494C27, 0x6F594528, 0x6F695460, 0x6F795461,
|
||
|
|
0x6F895462, 0x6F995463, 0x6FA95364, 0x6FB94E65, 0x6FC94A66, 0x6FD94767, 0x6FE954A0, 0x6FF954A1,
|
||
|
|
0x700954A2, 0x701954A3, 0x702953A4, 0x70394EA5, 0x70494AA6, 0x705947A7, 0x706954E0, 0x707954E1,
|
||
|
|
0x708953E2, 0x709950E3, 0x70A94DE4, 0x70B94AE5, 0x70C947E6, 0x70D944E7, 0x70E954B0, 0x70F954B1,
|
||
|
|
0x710954B2, 0x711954B3, 0x712953B4, 0x71394EB5, 0x71494AB6, 0x715947B7, 0x716954F0, 0x717954F1,
|
||
|
|
0x718953F2, 0x719950F3, 0x71A94DF4, 0x71B94AF5, 0x71C947F6, 0x71D944F7, 0x71E13404, 0x71F13405,
|
||
|
|
0x72013406, 0x72113407, 0x72213408, 0x72313409, 0x7241340A, 0x7251340B, 0x72613444, 0x72713445,
|
||
|
|
0x72813446, 0x72913447, 0x72A13448, 0x72B13449, 0x72C1344A, 0x72D1344B, 0x72E13484, 0x72F13485,
|
||
|
|
0x73013486, 0x73113487, 0x73213488, 0x73313489, 0x7341348A, 0x7351348B, 0x736134C4, 0x737134C5,
|
||
|
|
0x738134C6, 0x739134C7, 0x73A134C8, 0x73B134C9, 0x73C134CA, 0x73D134CB, 0x73E93401, 0x73F93402,
|
||
|
|
0x74093403, 0x74193404, 0x74293405, 0x74393406, 0x74493407, 0x74593408, 0x74693309, 0x74792F0A,
|
||
|
|
0x74892A0B, 0x74993441, 0x74A93442, 0x74B93443, 0x74C93444, 0x74D93445, 0x74E93446, 0x74F93247,
|
||
|
|
0x75092E48, 0x75192B49, 0x7529294A, 0x7539254B, 0x75493481, 0x75593482, 0x75693483, 0x75793484,
|
||
|
|
0x75893485, 0x75993486, 0x75A93287, 0x75B92E88, 0x75C92B89, 0x75D9298A, 0x75E9258B, 0x75F934C1,
|
||
|
|
0x760934C2, 0x761934C3, 0x762933C4, 0x763930C5, 0x76492EC6, 0x76592CC7, 0x76692AC8, 0x767927C9,
|
||
|
|
0x768925CA, 0x76993411, 0x76A93412, 0x76B93413, 0x76C93414, 0x76D93415, 0x76E93416, 0x76F93417,
|
||
|
|
0x77093418, 0x77193319, 0x77292F1A, 0x77392A1B, 0x77493451, 0x77593452, 0x77693453, 0x77793454,
|
||
|
|
0x77893455, 0x77993456, 0x77A93257, 0x77B92E58, 0x77C92B59, 0x77D9295A, 0x77E9255B, 0x77F93491,
|
||
|
|
0x78093492, 0x78193493, 0x78293494, 0x78393495, 0x78493496, 0x78593297, 0x78692E98, 0x78792B99,
|
||
|
|
0x7889299A, 0x7899259B, 0x78A934D1, 0x78B934D2, 0x78C934D3, 0x78D933D4, 0x78E930D5, 0x78F92ED6,
|
||
|
|
0x79092CD7, 0x79192AD8, 0x792927D9, 0x793925DA, 0x79493421, 0x79593422, 0x79693423, 0x79793424,
|
||
|
|
0x79893425, 0x79993426, 0x79A93427, 0x79B93428, 0x79C93329, 0x79D92F2A, 0x79E92A2B, 0x79F93461,
|
||
|
|
0x7A093462, 0x7A193463, 0x7A293464, 0x7A393465, 0x7A493466, 0x7A593267, 0x7A692E68, 0x7A792B69,
|
||
|
|
0x7A89296A, 0x7A99256B, 0x7AA934A1, 0x7AB934A2, 0x7AC934A3, 0x7AD934A4, 0x7AE934A5, 0x7AF934A6,
|
||
|
|
0x7B0932A7, 0x7B192EA8, 0x7B292BA9, 0x7B3929AA, 0x7B4925AB, 0x7B5934E1, 0x7B6934E2, 0x7B7934E3,
|
||
|
|
0x7B8933E4, 0x7B9930E5, 0x7BA92EE6, 0x7BB92CE7, 0x7BC92AE8, 0x7BD927E9, 0x7BE925EA, 0x7BF934B1,
|
||
|
|
0x7C0934B2, 0x7C1934B3, 0x7C2934B4, 0x7C3934B5, 0x7C4934B6, 0x7C5932B7, 0x7C692EB8, 0x7C792BB9,
|
||
|
|
0x7C8929BA, 0x7C9925BB, 0x7CA934F1, 0x7CB934F2, 0x7CC934F3, 0x7CD933F4, 0x7CE930F5, 0x7CF92EF6,
|
||
|
|
0x7D092CF7, 0x7D192AF8, 0x7D2927F9, 0x7D3925FA, 0x7D441402, 0x7D541403, 0x7D641404, 0x7D741405,
|
||
|
|
0x7D841406, 0x7D941407, 0x7DA41408, 0x7DB41409, 0x7DC4140A, 0x7DD4140B, 0x7DE41442, 0x7DF41443,
|
||
|
|
0x7E041444, 0x7E141445, 0x7E241446, 0x7E341447, 0x7E441448, 0x7E541449, 0x7E64144A, 0x7E74144B,
|
||
|
|
0x7E841482, 0x7E941483, 0x7EA41484, 0x7EB41485, 0x7EC41486, 0x7ED41487, 0x7EE41488, 0x7EF41489,
|
||
|
|
0x7F04148A, 0x7F14148B, 0x7F2414C2, 0x7F3414C3, 0x7F4414C4, 0x7F5414C5, 0x7F6414C6, 0x7F7414C7,
|
||
|
|
0x7F8413C8, 0x7F9412C9, 0x7FA410CA, 0x7FB40FCB, 0x7FCC1400, 0x7FDC1401, 0x7FEC1402, 0x7FFC1403,
|
||
|
|
0x800C1404, 0x801C1405, 0x802C1106, 0x803C0C07, 0x804C0508, 0x805C1440, 0x806C1441, 0x807C1442,
|
||
|
|
0x808C1443, 0x809C1344, 0x80AC0E45, 0x80BC0A46, 0x80CC0747, 0x80DC1480, 0x80EC1481, 0x80FC1482,
|
||
|
|
0x810C1483, 0x811C1384, 0x812C0E85, 0x813C0A86, 0x814C0787, 0x815C14C0, 0x816C14C1, 0x817C13C2,
|
||
|
|
0x818C10C3, 0x819C0DC4, 0x81AC0AC5, 0x81BC07C6, 0x81CC04C7, 0x81DC1410, 0x81EC1411, 0x81FC1412,
|
||
|
|
0x820C1413, 0x821C1414, 0x822C1415, 0x823C1116, 0x824C0C17, 0x825C0518, 0x826C1450, 0x827C1451,
|
||
|
|
0x828C1452, 0x829C1453, 0x82AC1354, 0x82BC0E55, 0x82CC0A56, 0x82DC0757, 0x82EC1490, 0x82FC1491,
|
||
|
|
0x830C1492, 0x831C1493, 0x832C1394, 0x833C0E95, 0x834C0A96, 0x835C0797, 0x836C14D0, 0x837C14D1,
|
||
|
|
0x838C13D2, 0x839C10D3, 0x83AC0DD4, 0x83BC0AD5, 0x83CC07D6, 0x83DC04D7, 0x83EC1420, 0x83FC1421,
|
||
|
|
0x840C1422, 0x841C1423, 0x842C1424, 0x843C1425, 0x844C1126, 0x845C0C27, 0x846C0528, 0x847C1460,
|
||
|
|
0x848C1461, 0x849C1462, 0x84AC1463, 0x84BC1364, 0x84CC0E65, 0x84DC0A66, 0x84EC0767, 0x84FC14A0,
|
||
|
|
0x850C14A1, 0x851C14A2, 0x852C14A3, 0x853C13A4, 0x854C0EA5, 0x855C0AA6, 0x856C07A7, 0x857C14E0,
|
||
|
|
0x858C14E1, 0x859C13E2, 0x85AC10E3, 0x85BC0DE4, 0x85CC0AE5, 0x85DC07E6, 0x85EC04E7, 0x85FC14B0,
|
||
|
|
0x860C14B1, 0x861C14B2, 0x862C14B3, 0x863C13B4, 0x864C0EB5, 0x865C0AB6, 0x866C07B7, 0x867C14F0,
|
||
|
|
0x868C14F1, 0x869C13F2, 0x86AC10F3, 0x86BC0DF4, 0x86CC0AF5, 0x86DC07F6, 0x86EC04F7, 0x86F09402,
|
||
|
|
0x87009403, 0x87109404, 0x87209405, 0x87309406, 0x87409407, 0x87509408, 0x87609409, 0x8770940A,
|
||
|
|
0x8780940B, 0x87909442, 0x87A09443, 0x87B09444, 0x87C09445, 0x87D09446, 0x87E09447, 0x87F09448,
|
||
|
|
0x88009449, 0x8810944A, 0x8820944B, 0x88309482, 0x88409483, 0x88509484, 0x88609485, 0x88709486,
|
||
|
|
0x88809487, 0x88909488, 0x88A09489, 0x88B0948A, 0x88C0948B, 0x88D094C2, 0x88E094C3, 0x88F094C4,
|
||
|
|
0x890094C5, 0x891094C6, 0x892094C7, 0x893093C8, 0x894092C9, 0x895090CA, 0x89608FCB, 0x89789400,
|
||
|
|
0x89889401, 0x89989402, 0x89A89403, 0x89B89404, 0x89C89405, 0x89D89106, 0x89E88C07, 0x89F88508,
|
||
|
|
0x8A089440, 0x8A189441, 0x8A289442, 0x8A389443, 0x8A489344, 0x8A588E45, 0x8A688A46, 0x8A788747,
|
||
|
|
0x8A889480, 0x8A989481, 0x8AA89482, 0x8AB89483, 0x8AC89384, 0x8AD88E85, 0x8AE88A86, 0x8AF88787,
|
||
|
|
0x8B0894C0, 0x8B1894C1, 0x8B2893C2, 0x8B3890C3, 0x8B488DC4, 0x8B588AC5, 0x8B6887C6, 0x8B7884C7,
|
||
|
|
0x8B889410, 0x8B989411, 0x8BA89412, 0x8BB89413, 0x8BC89414, 0x8BD89415, 0x8BE89116, 0x8BF88C17,
|
||
|
|
0x8C088518, 0x8C189450, 0x8C289451, 0x8C389452, 0x8C489453, 0x8C589354, 0x8C688E55, 0x8C788A56,
|
||
|
|
0x8C888757, 0x8C989490, 0x8CA89491, 0x8CB89492, 0x8CC89493, 0x8CD89394, 0x8CE88E95, 0x8CF88A96,
|
||
|
|
0x8D088797, 0x8D1894D0, 0x8D2894D1, 0x8D3893D2, 0x8D4890D3, 0x8D588DD4, 0x8D688AD5, 0x8D7887D6,
|
||
|
|
0x8D8884D7, 0x8D989420, 0x8DA89421, 0x8DB89422, 0x8DC89423, 0x8DD89424, 0x8DE89425, 0x8DF89126,
|
||
|
|
0x8E088C27, 0x8E188528, 0x8E289460, 0x8E389461, 0x8E489462, 0x8E589463, 0x8E689364, 0x8E788E65,
|
||
|
|
0x8E888A66, 0x8E988767, 0x8EA894A0, 0x8EB894A1, 0x8EC894A2, 0x8ED894A3, 0x8EE893A4, 0x8EF88EA5,
|
||
|
|
0x8F088AA6, 0x8F1887A7, 0x8F2894E0, 0x8F3894E1, 0x8F4893E2, 0x8F5890E3, 0x8F688DE4, 0x8F788AE5,
|
||
|
|
0x8F8887E6, 0x8F9884E7, 0x8FA894B0, 0x8FB894B1, 0x8FC894B2, 0x8FD894B3, 0x8FE893B4, 0x8FF88EB5,
|
||
|
|
0x90088AB6, 0x901887B7, 0x902894F0, 0x903894F1, 0x904893F2, 0x905890F3, 0x90688DF4, 0x90788AF5,
|
||
|
|
0x908887F6, 0x909884F7, 0x90A31403, 0x90B31404, 0x90C31405, 0x90D31406, 0x90E31407, 0x90F31408,
|
||
|
|
0x91031409, 0x9113140A, 0x9123140B, 0x91331443, 0x91431444, 0x91531445, 0x91631446, 0x91731447,
|
||
|
|
0x91831448, 0x91931449, 0x91A3144A, 0x91B3144B, 0x91C31483, 0x91D31484, 0x91E31485, 0x91F31486,
|
||
|
|
0x92031487, 0x92131488, 0x92231489, 0x9233148A, 0x9243148B, 0x925314C3, 0x926314C4, 0x927314C5,
|
||
|
|
0x928314C6, 0x929314C7, 0x92A314C8, 0x92B314C9, 0x92C314CA, 0x92D313CB, 0x92EB1401, 0x92FB1402,
|
||
|
|
0x930B1403, 0x931B1404, 0x932B1405, 0x933B1406, 0x934B1407, 0x935B1108, 0x936B0C09, 0x937B080A,
|
||
|
|
0x938B1441, 0x939B1442, 0x93AB1443, 0x93BB1444, 0x93CB1445, 0x93DB1146, 0x93EB0E47, 0x93FB0A48,
|
||
|
|
0x940B0749, 0x941B044A, 0x942B1481, 0x943B1482, 0x944B1483, 0x945B1484, 0x946B1485, 0x947B1186,
|
||
|
|
0x948B0E87, 0x949B0A88, 0x94AB0789, 0x94BB048A, 0x94CB14C1, 0x94DB14C2, 0x94EB13C3, 0x94FB11C4,
|
||
|
|
0x950B0EC5, 0x951B0BC6, 0x952B0AC7, 0x953B07C8, 0x954B04C9, 0x955B1411, 0x956B1412, 0x957B1413,
|
||
|
|
0x958B1414, 0x959B1415, 0x95AB1416, 0x95BB1417, 0x95CB1118, 0x95DB0C19, 0x95EB081A, 0x95FB1451,
|
||
|
|
0x960B1452, 0x961B1453, 0x962B1454, 0x963B1455, 0x964B1156, 0x965B0E57, 0x966B0A58, 0x967B0759,
|
||
|
|
0x968B045A, 0x969B1491, 0x96AB1492, 0x96BB1493, 0x96CB1494, 0x96DB1495, 0x96EB1196, 0x96FB0E97,
|
||
|
|
0x970B0A98, 0x971B0799, 0x972B049A, 0x973B14D1, 0x974B14D2, 0x975B13D3, 0x976B11D4, 0x977B0ED5,
|
||
|
|
0x978B0BD6, 0x979B0AD7, 0x97AB07D8, 0x97BB04D9, 0x97CB1421, 0x97DB1422, 0x97EB1423, 0x97FB1424,
|
||
|
|
0x980B1425, 0x981B1426, 0x982B1427, 0x983B1128, 0x984B0C29, 0x985B082A, 0x986B1461, 0x987B1462,
|
||
|
|
0x988B1463, 0x989B1464, 0x98AB1465, 0x98BB1166, 0x98CB0E67, 0x98DB0A68, 0x98EB0769, 0x98FB046A,
|
||
|
|
0x990B14A1, 0x991B14A2, 0x992B14A3, 0x993B14A4, 0x994B14A5, 0x995B11A6, 0x996B0EA7, 0x997B0AA8,
|
||
|
|
0x998B07A9, 0x999B04AA, 0x99AB14E1, 0x99BB14E2, 0x99CB13E3, 0x99DB11E4, 0x99EB0EE5, 0x99FB0BE6,
|
||
|
|
0x9A0B0AE7, 0x9A1B07E8, 0x9A2B04E9, 0x9A3B14B1, 0x9A4B14B2, 0x9A5B14B3, 0x9A6B14B4, 0x9A7B14B5,
|
||
|
|
0x9A8B11B6, 0x9A9B0EB7, 0x9AAB0AB8, 0x9ABB07B9, 0x9ACB04BA, 0x9ADB14F1, 0x9AEB14F2, 0x9AFB13F3,
|
||
|
|
0x9B0B11F4, 0x9B1B0EF5, 0x9B2B0BF6, 0x9B3B0AF7, 0x9B4B07F8, 0x9B5B04F9, 0x9B607403, 0x9B707404,
|
||
|
|
0x9B807405, 0x9B907406, 0x9BA07407, 0x9BB07408, 0x9BC07409, 0x9BD0740A, 0x9BE0740B, 0x9BF07443,
|
||
|
|
0x9C007444, 0x9C107445, 0x9C207446, 0x9C307447, 0x9C407448, 0x9C507449, 0x9C60744A, 0x9C70744B,
|
||
|
|
0x9C807483, 0x9C907484, 0x9CA07485, 0x9CB07486, 0x9CC07487, 0x9CD07488, 0x9CE07489, 0x9CF0748A,
|
||
|
|
0x9D00748B, 0x9D1074C3, 0x9D2074C4, 0x9D3074C5, 0x9D4074C6, 0x9D5074C7, 0x9D6074C8, 0x9D7074C9,
|
||
|
|
0x9D8074CA, 0x9D9073CB, 0x9DA87401, 0x9DB87402, 0x9DC87403, 0x9DD87404, 0x9DE87405, 0x9DF87406,
|
||
|
|
0x9E087407, 0x9E187108, 0x9E286C09, 0x9E38680A, 0x9E487441, 0x9E587442, 0x9E687443, 0x9E787444,
|
||
|
|
0x9E887445, 0x9E987146, 0x9EA86E47, 0x9EB86A48, 0x9EC86749, 0x9ED8644A, 0x9EE87481, 0x9EF87482,
|
||
|
|
0x9F087483, 0x9F187484, 0x9F287485, 0x9F387186, 0x9F486E87, 0x9F586A88, 0x9F686789, 0x9F78648A,
|
||
|
|
0x9F8874C1, 0x9F9874C2, 0x9FA873C3, 0x9FB871C4, 0x9FC86EC5, 0x9FD86BC6, 0x9FE86AC7, 0x9FF867C8,
|
||
|
|
0xA00864C9, 0xA0187411, 0xA0287412, 0xA0387413, 0xA0487414, 0xA0587415, 0xA0687416, 0xA0787417,
|
||
|
|
0xA0887118, 0xA0986C19, 0xA0A8681A, 0xA0B87451, 0xA0C87452, 0xA0D87453, 0xA0E87454, 0xA0F87455,
|
||
|
|
0xA1087156, 0xA1186E57, 0xA1286A58, 0xA1386759, 0xA148645A, 0xA1587491, 0xA1687492, 0xA1787493,
|
||
|
|
0xA1887494, 0xA1987495, 0xA1A87196, 0xA1B86E97, 0xA1C86A98, 0xA1D86799, 0xA1E8649A, 0xA1F874D1,
|
||
|
|
0xA20874D2, 0xA21873D3, 0xA22871D4, 0xA2386ED5, 0xA2486BD6, 0xA2586AD7, 0xA26867D8, 0xA27864D9,
|
||
|
|
0xA2887421, 0xA2987422, 0xA2A87423, 0xA2B87424, 0xA2C87425, 0xA2D87426, 0xA2E87427, 0xA2F87128,
|
||
|
|
0xA3086C29, 0xA318682A, 0xA3287461, 0xA3387462, 0xA3487463, 0xA3587464, 0xA3687465, 0xA3787166,
|
||
|
|
0xA3886E67, 0xA3986A68, 0xA3A86769, 0xA3B8646A, 0xA3C874A1, 0xA3D874A2, 0xA3E874A3, 0xA3F874A4,
|
||
|
|
0xA40874A5, 0xA41871A6, 0xA4286EA7, 0xA4386AA8, 0xA44867A9, 0xA45864AA, 0xA46874E1, 0xA47874E2,
|
||
|
|
0xA48873E3, 0xA49871E4, 0xA4A86EE5, 0xA4B86BE6, 0xA4C86AE7, 0xA4D867E8, 0xA4E864E9, 0xA4F874B1,
|
||
|
|
0xA50874B2, 0xA51874B3, 0xA52874B4, 0xA53874B5, 0xA54871B6, 0xA5586EB7, 0xA5686AB8, 0xA57867B9,
|
||
|
|
0xA58864BA, 0xA59874F1, 0xA5A874F2, 0xA5B873F3, 0xA5C871F4, 0xA5D86EF5, 0xA5E86BF6, 0xA5F86AF7,
|
||
|
|
0xA60867F8, 0xA61864F9, 0xA6221405, 0xA6321406, 0xA6421407, 0xA6521408, 0xA6621409, 0xA672140A,
|
||
|
|
0xA682140B, 0xA6921445, 0xA6A21446, 0xA6B21447, 0xA6C21448, 0xA6D21449, 0xA6E2144A, 0xA6F2144B,
|
||
|
|
0xA7021485, 0xA7121486, 0xA7221487, 0xA7321488, 0xA7421489, 0xA752148A, 0xA762148B, 0xA77214C5,
|
||
|
|
0xA78214C6, 0xA79214C7, 0xA7A214C8, 0xA7B214C9, 0xA7C214CA, 0xA7D214CB, 0xA7EA1401, 0xA7FA1402,
|
||
|
|
0xA80A1403, 0xA81A1404, 0xA82A1405, 0xA83A1406, 0xA84A1407, 0xA85A1408, 0xA86A1409, 0xA87A140A,
|
||
|
|
0xA88A110B, 0xA89A1441, 0xA8AA1442, 0xA8BA1443, 0xA8CA1444, 0xA8DA1445, 0xA8EA1446, 0xA8FA1447,
|
||
|
|
0xA90A1248, 0xA91A0F49, 0xA92A0D4A, 0xA93A0A4B, 0xA94A1481, 0xA95A1482, 0xA96A1483, 0xA97A1484,
|
||
|
|
0xA98A1485, 0xA99A1486, 0xA9AA1487, 0xA9BA1288, 0xA9CA0F89, 0xA9DA0D8A, 0xA9EA0A8B, 0xA9FA14C1,
|
||
|
|
0xAA0A14C2, 0xAA1A14C3, 0xAA2A14C4, 0xAA3A13C5, 0xAA4A10C6, 0xAA5A0FC7, 0xAA6A0DC8, 0xAA7A0AC9,
|
||
|
|
0xAA8A09CA, 0xAA9A07CB, 0xAAAA1411, 0xAABA1412, 0xAACA1413, 0xAADA1414, 0xAAEA1415, 0xAAFA1416,
|
||
|
|
0xAB0A1417, 0xAB1A1418, 0xAB2A1419, 0xAB3A141A, 0xAB4A111B, 0xAB5A1451, 0xAB6A1452, 0xAB7A1453,
|
||
|
|
0xAB8A1454, 0xAB9A1455, 0xABAA1456, 0xABBA1457, 0xABCA1258, 0xABDA0F59, 0xABEA0D5A, 0xABFA0A5B,
|
||
|
|
0xAC0A1491, 0xAC1A1492, 0xAC2A1493, 0xAC3A1494, 0xAC4A1495, 0xAC5A1496, 0xAC6A1497, 0xAC7A1298,
|
||
|
|
0xAC8A0F99, 0xAC9A0D9A, 0xACAA0A9B, 0xACBA14D1, 0xACCA14D2, 0xACDA14D3, 0xACEA14D4, 0xACFA13D5,
|
||
|
|
0xAD0A10D6, 0xAD1A0FD7, 0xAD2A0DD8, 0xAD3A0AD9, 0xAD4A09DA, 0xAD5A07DB, 0xAD6A1421, 0xAD7A1422,
|
||
|
|
0xAD8A1423, 0xAD9A1424, 0xADAA1425, 0xADBA1426, 0xADCA1427, 0xADDA1428, 0xADEA1429, 0xADFA142A,
|
||
|
|
0xAE0A112B, 0xAE1A1461, 0xAE2A1462, 0xAE3A1463, 0xAE4A1464, 0xAE5A1465, 0xAE6A1466, 0xAE7A1467,
|
||
|
|
0xAE8A1268, 0xAE9A0F69, 0xAEAA0D6A, 0xAEBA0A6B, 0xAECA14A1, 0xAEDA14A2, 0xAEEA14A3, 0xAEFA14A4,
|
||
|
|
0xAF0A14A5, 0xAF1A14A6, 0xAF2A14A7, 0xAF3A12A8, 0xAF4A0FA9, 0xAF5A0DAA, 0xAF6A0AAB, 0xAF7A14E1,
|
||
|
|
0xAF8A14E2, 0xAF9A14E3, 0xAFAA14E4, 0xAFBA13E5, 0xAFCA10E6, 0xAFDA0FE7, 0xAFEA0DE8, 0xAFFA0AE9,
|
||
|
|
0xB00A09EA, 0xB01A07EB, 0xB02A14B1, 0xB03A14B2, 0xB04A14B3, 0xB05A14B4, 0xB06A14B5, 0xB07A14B6,
|
||
|
|
0xB08A14B7, 0xB09A12B8, 0xB0AA0FB9, 0xB0BA0DBA, 0xB0CA0ABB, 0xB0DA14F1, 0xB0EA14F2, 0xB0FA14F3,
|
||
|
|
0xB10A14F4, 0xB11A13F5, 0xB12A10F6, 0xB13A0FF7, 0xB14A0DF8, 0xB15A0AF9, 0xB16A09FA, 0xB17A07FB,
|
||
|
|
0xB1805405, 0xB1905406, 0xB1A05407, 0xB1B05408, 0xB1C05409, 0xB1D0540A, 0xB1E0540B, 0xB1F05445,
|
||
|
|
0xB2005446, 0xB2105447, 0xB2205448, 0xB2305449, 0xB240544A, 0xB250544B, 0xB2605485, 0xB2705486,
|
||
|
|
0xB2805487, 0xB2905488, 0xB2A05489, 0xB2B0548A, 0xB2C0548B, 0xB2D054C5, 0xB2E054C6, 0xB2F054C7,
|
||
|
|
0xB30054C8, 0xB31054C9, 0xB32054CA, 0xB33054CB, 0xB3485401, 0xB3585402, 0xB3685403, 0xB3785404,
|
||
|
|
0xB3885405, 0xB3985406, 0xB3A85407, 0xB3B85408, 0xB3C85409, 0xB3D8540A, 0xB3E8510B, 0xB3F85441,
|
||
|
|
0xB4085442, 0xB4185443, 0xB4285444, 0xB4385445, 0xB4485446, 0xB4585447, 0xB4685248, 0xB4784F49,
|
||
|
|
0xB4884D4A, 0xB4984A4B, 0xB4A85481, 0xB4B85482, 0xB4C85483, 0xB4D85484, 0xB4E85485, 0xB4F85486,
|
||
|
|
0xB5085487, 0xB5185288, 0xB5284F89, 0xB5384D8A, 0xB5484A8B, 0xB55854C1, 0xB56854C2, 0xB57854C3,
|
||
|
|
0xB58854C4, 0xB59853C5, 0xB5A850C6, 0xB5B84FC7, 0xB5C84DC8, 0xB5D84AC9, 0xB5E849CA, 0xB5F847CB,
|
||
|
|
0xB6085411, 0xB6185412, 0xB6285413, 0xB6385414, 0xB6485415, 0xB6585416, 0xB6685417, 0xB6785418,
|
||
|
|
0xB6885419, 0xB698541A, 0xB6A8511B, 0xB6B85451, 0xB6C85452, 0xB6D85453, 0xB6E85454, 0xB6F85455,
|
||
|
|
0xB7085456, 0xB7185457, 0xB7285258, 0xB7384F59, 0xB7484D5A, 0xB7584A5B, 0xB7685491, 0xB7785492,
|
||
|
|
0xB7885493, 0xB7985494, 0xB7A85495, 0xB7B85496, 0xB7C85497, 0xB7D85298, 0xB7E84F99, 0xB7F84D9A,
|
||
|
|
0xB8084A9B, 0xB81854D1, 0xB82854D2, 0xB83854D3, 0xB84854D4, 0xB85853D5, 0xB86850D6, 0xB8784FD7,
|
||
|
|
0xB8884DD8, 0xB8984AD9, 0xB8A849DA, 0xB8B847DB, 0xB8C85421, 0xB8D85422, 0xB8E85423, 0xB8F85424,
|
||
|
|
0xB9085425, 0xB9185426, 0xB9285427, 0xB9385428, 0xB9485429, 0xB958542A, 0xB968512B, 0xB9785461,
|
||
|
|
0xB9885462, 0xB9985463, 0xB9A85464, 0xB9B85465, 0xB9C85466, 0xB9D85467, 0xB9E85268, 0xB9F84F69,
|
||
|
|
0xBA084D6A, 0xBA184A6B, 0xBA2854A1, 0xBA3854A2, 0xBA4854A3, 0xBA5854A4, 0xBA6854A5, 0xBA7854A6,
|
||
|
|
0xBA8854A7, 0xBA9852A8, 0xBAA84FA9, 0xBAB84DAA, 0xBAC84AAB, 0xBAD854E1, 0xBAE854E2, 0xBAF854E3,
|
||
|
|
0xBB0854E4, 0xBB1853E5, 0xBB2850E6, 0xBB384FE7, 0xBB484DE8, 0xBB584AE9, 0xBB6849EA, 0xBB7847EB,
|
||
|
|
0xBB8854B1, 0xBB9854B2, 0xBBA854B3, 0xBBB854B4, 0xBBC854B5, 0xBBD854B6, 0xBBE854B7, 0xBBF852B8,
|
||
|
|
0xBC084FB9, 0xBC184DBA, 0xBC284ABB, 0xBC3854F1, 0xBC4854F2, 0xBC5854F3, 0xBC6854F4, 0xBC7853F5,
|
||
|
|
0xBC8850F6, 0xBC984FF7, 0xBCA84DF8, 0xBCB84AF9, 0xBCC849FA, 0xBCD847FB, 0xBCE11408, 0xBCF11409,
|
||
|
|
0xBD01140A, 0xBD11140B, 0xBD211448, 0xBD311449, 0xBD41144A, 0xBD51144B, 0xBD611488, 0xBD711489,
|
||
|
|
0xBD81148A, 0xBD91148B, 0xBDA114C8, 0xBDB114C9, 0xBDC114CA, 0xBDD114CB, 0xBDE91402, 0xBDF91403,
|
||
|
|
0xBE091404, 0xBE191405, 0xBE291406, 0xBE391407, 0xBE491408, 0xBE591409, 0xBE69140A, 0xBE79140B,
|
||
|
|
0xBE891442, 0xBE991443, 0xBEA91444, 0xBEB91445, 0xBEC91446, 0xBED91447, 0xBEE91448, 0xBEF91449,
|
||
|
|
0xBF09144A, 0xBF19144B, 0xBF291482, 0xBF391483, 0xBF491484, 0xBF591485, 0xBF691486, 0xBF791487,
|
||
|
|
0xBF891488, 0xBF991489, 0xBFA9148A, 0xBFB9148B, 0xBFC914C2, 0xBFD914C3, 0xBFE914C4, 0xBFF914C5,
|
||
|
|
0xC00914C6, 0xC01914C7, 0xC02913C8, 0xC03911C9, 0xC04910CA, 0xC0590ECB, 0xC0691412, 0xC0791413,
|
||
|
|
0xC0891414, 0xC0991415, 0xC0A91416, 0xC0B91417, 0xC0C91418, 0xC0D91419, 0xC0E9141A, 0xC0F9141B,
|
||
|
|
0xC1091452, 0xC1191453, 0xC1291454, 0xC1391455, 0xC1491456, 0xC1591457, 0xC1691458, 0xC1791459,
|
||
|
|
0xC189145A, 0xC199145B, 0xC1A91492, 0xC1B91493, 0xC1C91494, 0xC1D91495, 0xC1E91496, 0xC1F91497,
|
||
|
|
0xC2091498, 0xC2191499, 0xC229149A, 0xC239149B, 0xC24914D2, 0xC25914D3, 0xC26914D4, 0xC27914D5,
|
||
|
|
0xC28914D6, 0xC29914D7, 0xC2A913D8, 0xC2B911D9, 0xC2C910DA, 0xC2D90EDB, 0xC2E91422, 0xC2F91423,
|
||
|
|
0xC3091424, 0xC3191425, 0xC3291426, 0xC3391427, 0xC3491428, 0xC3591429, 0xC369142A, 0xC379142B,
|
||
|
|
0xC3891462, 0xC3991463, 0xC3A91464, 0xC3B91465, 0xC3C91466, 0xC3D91467, 0xC3E91468, 0xC3F91469,
|
||
|
|
0xC409146A, 0xC419146B, 0xC42914A2, 0xC43914A3, 0xC44914A4, 0xC45914A5, 0xC46914A6, 0xC47914A7,
|
||
|
|
0xC48914A8, 0xC49914A9, 0xC4A914AA, 0xC4B914AB, 0xC4C914E2, 0xC4D914E3, 0xC4E914E4, 0xC4F914E5,
|
||
|
|
0xC50914E6, 0xC51914E7, 0xC52913E8, 0xC53911E9, 0xC54910EA, 0xC5590EEB, 0xC56914B2, 0xC57914B3,
|
||
|
|
0xC58914B4, 0xC59914B5, 0xC5A914B6, 0xC5B914B7, 0xC5C914B8, 0xC5D914B9, 0xC5E914BA, 0xC5F914BB,
|
||
|
|
0xC60914F2, 0xC61914F3, 0xC62914F4, 0xC63914F5, 0xC64914F6, 0xC65914F7, 0xC66913F8, 0xC67911F9,
|
||
|
|
0xC68910FA, 0xC6990EFB, 0xC6A03408, 0xC6B03409, 0xC6C0340A, 0xC6D0340B, 0xC6E03448, 0xC6F03449,
|
||
|
|
0xC700344A, 0xC710344B, 0xC7203488, 0xC7303489, 0xC740348A, 0xC750348B, 0xC76034C8, 0xC77034C9,
|
||
|
|
0xC78034CA, 0xC79034CB, 0xC7A83402, 0xC7B83403, 0xC7C83404, 0xC7D83405, 0xC7E83406, 0xC7F83407,
|
||
|
|
0xC8083408, 0xC8183409, 0xC828340A, 0xC838340B, 0xC8483442, 0xC8583443, 0xC8683444, 0xC8783445,
|
||
|
|
0xC8883446, 0xC8983447, 0xC8A83448, 0xC8B83449, 0xC8C8344A, 0xC8D8344B, 0xC8E83482, 0xC8F83483,
|
||
|
|
0xC9083484, 0xC9183485, 0xC9283486, 0xC9383487, 0xC9483488, 0xC9583489, 0xC968348A, 0xC978348B,
|
||
|
|
0xC98834C2, 0xC99834C3, 0xC9A834C4, 0xC9B834C5, 0xC9C834C6, 0xC9D834C7, 0xC9E833C8, 0xC9F831C9,
|
||
|
|
0xCA0830CA, 0xCA182ECB, 0xCA283412, 0xCA383413, 0xCA483414, 0xCA583415, 0xCA683416, 0xCA783417,
|
||
|
|
0xCA883418, 0xCA983419, 0xCAA8341A, 0xCAB8341B, 0xCAC83452, 0xCAD83453, 0xCAE83454, 0xCAF83455,
|
||
|
|
0xCB083456, 0xCB183457, 0xCB283458, 0xCB383459, 0xCB48345A, 0xCB58345B, 0xCB683492, 0xCB783493,
|
||
|
|
0xCB883494, 0xCB983495, 0xCBA83496, 0xCBB83497, 0xCBC83498, 0xCBD83499, 0xCBE8349A, 0xCBF8349B,
|
||
|
|
0xCC0834D2, 0xCC1834D3, 0xCC2834D4, 0xCC3834D5, 0xCC4834D6, 0xCC5834D7, 0xCC6833D8, 0xCC7831D9,
|
||
|
|
0xCC8830DA, 0xCC982EDB, 0xCCA83422, 0xCCB83423, 0xCCC83424, 0xCCD83425, 0xCCE83426, 0xCCF83427,
|
||
|
|
0xCD083428, 0xCD183429, 0xCD28342A, 0xCD38342B, 0xCD483462, 0xCD583463, 0xCD683464, 0xCD783465,
|
||
|
|
0xCD883466, 0xCD983467, 0xCDA83468, 0xCDB83469, 0xCDC8346A, 0xCDD8346B, 0xCDE834A2, 0xCDF834A3,
|
||
|
|
0xCE0834A4, 0xCE1834A5, 0xCE2834A6, 0xCE3834A7, 0xCE4834A8, 0xCE5834A9, 0xCE6834AA, 0xCE7834AB,
|
||
|
|
0xCE8834E2, 0xCE9834E3, 0xCEA834E4, 0xCEB834E5, 0xCEC834E6, 0xCED834E7, 0xCEE833E8, 0xCEF831E9,
|
||
|
|
0xCF0830EA, 0xCF182EEB, 0xCF2834B2, 0xCF3834B3, 0xCF4834B4, 0xCF5834B5, 0xCF6834B6, 0xCF7834B7,
|
||
|
|
0xCF8834B8, 0xCF9834B9, 0xCFA834BA, 0xCFB834BB, 0xCFC834F2, 0xCFD834F3, 0xCFE834F4, 0xCFF834F5,
|
||
|
|
0xD00834F6, 0xD01834F7, 0xD02833F8, 0xD03831F9, 0xD04830FA, 0xD0582EFB,
|
||
|
|
};
|
||
|
|
|
||
|
|
uniform int get_bits(uniform uint32_t value, uniform int from, uniform int to)
|
||
|
|
{
|
||
|
|
return (value >> from) & ((1 << (to + 1 - from)) - 1);
|
||
|
|
}
|
||
|
|
|
||
|
|
void load_mode_parameters(uniform astc_mode* uniform mode, uniform uint32_t packed_mode)
|
||
|
|
{
|
||
|
|
mode->width = 2 + get_bits(packed_mode, 13, 15); // 2..8 <= 2^3
|
||
|
|
mode->height = 2 + get_bits(packed_mode, 16, 18); // 2..8 <= 2^3
|
||
|
|
mode->dual_plane = get_bits(packed_mode, 19, 19); // 0 or 1
|
||
|
|
mode->partitions = 1;
|
||
|
|
|
||
|
|
mode->weight_range = get_bits(packed_mode, 0, 3); // 0..11 <= 2^4
|
||
|
|
mode->color_component_selector = get_bits(packed_mode, 4, 5); // 0..2 <= 2^2
|
||
|
|
mode->partition_id = 0;
|
||
|
|
mode->color_endpoint_modes[0] = get_bits(packed_mode, 6, 7) * 2 + 6; // 6 or 8
|
||
|
|
mode->color_endpoint_pairs = 1 + (mode->color_endpoint_modes[0] / 4);
|
||
|
|
mode->endpoint_range = get_bits(packed_mode, 8, 12); // 0..20 <= 2^5
|
||
|
|
}
|
||
|
|
|
||
|
|
export void astc_rank_ispc(uniform rgba_surface src[], uniform int xx, uniform int yy, uniform uint32_t mode_buffer[], uniform astc_enc_settings settings[])
|
||
|
|
{
|
||
|
|
int tex_width = src->width / settings->block_width;
|
||
|
|
if (xx + programIndex >= tex_width) return;
|
||
|
|
|
||
|
|
astc_rank_state _state;
|
||
|
|
varying astc_rank_state* uniform state = &_state;
|
||
|
|
|
||
|
|
state->block_width = settings->block_width;
|
||
|
|
state->block_height = settings->block_height;
|
||
|
|
state->fastSkipTreshold = settings->fastSkipTreshold;
|
||
|
|
|
||
|
|
assert(state->fastSkipTreshold <= 64);
|
||
|
|
|
||
|
|
load_block_interleaved(state->pixels, src, xx + programIndex, yy, state->block_width, state->block_height);
|
||
|
|
if (settings->channels == 3) clear_alpha(state->pixels, state->block_width, state->block_height);
|
||
|
|
|
||
|
|
compute_metrics(state);
|
||
|
|
|
||
|
|
float threshold_error = 0;
|
||
|
|
int count = -1;
|
||
|
|
|
||
|
|
for (uniform int id = 0; id < packed_modes_count; id++)
|
||
|
|
{
|
||
|
|
uniform uint32_t packed_mode = packed_modes[id];
|
||
|
|
|
||
|
|
uniform astc_mode _mode;
|
||
|
|
uniform astc_mode* uniform mode = &_mode;
|
||
|
|
load_mode_parameters(mode, packed_mode);
|
||
|
|
|
||
|
|
if (mode->height > state->block_height) continue;
|
||
|
|
if (mode->width > state->block_width) continue;
|
||
|
|
|
||
|
|
if (settings->channels == 3 && mode->color_endpoint_modes[0] > 8) continue;
|
||
|
|
|
||
|
|
float error = estimate_error(state, mode);
|
||
|
|
count += 1;
|
||
|
|
|
||
|
|
if (count < state->fastSkipTreshold)
|
||
|
|
{
|
||
|
|
state->best_modes[count] = packed_mode;
|
||
|
|
state->best_scores[count] = error;
|
||
|
|
|
||
|
|
threshold_error = max(threshold_error, error);
|
||
|
|
}
|
||
|
|
else if (error < threshold_error)
|
||
|
|
{
|
||
|
|
insert_element(state, error, packed_mode, &threshold_error);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
assert(count >= 0);
|
||
|
|
|
||
|
|
for (uniform int i = 0; i < state->fastSkipTreshold; i++)
|
||
|
|
{
|
||
|
|
mode_buffer[programCount * i + programIndex] = state->best_modes[i];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
///////////////////////////////////////////////////////////
|
||
|
|
// ASTC candidate encoding
|
||
|
|
|
||
|
|
struct astc_block
|
||
|
|
{
|
||
|
|
uniform int width;
|
||
|
|
uniform int height;
|
||
|
|
uniform uint8_t dual_plane;
|
||
|
|
int weight_range;
|
||
|
|
uint8_t weights[64];
|
||
|
|
int color_component_selector;
|
||
|
|
|
||
|
|
uniform int partitions;
|
||
|
|
int partition_id;
|
||
|
|
uniform int color_endpoint_pairs;
|
||
|
|
uniform int channels;
|
||
|
|
int color_endpoint_modes[4];
|
||
|
|
int endpoint_range;
|
||
|
|
uint8_t endpoints[18];
|
||
|
|
};
|
||
|
|
|
||
|
|
struct astc_enc_state
|
||
|
|
{
|
||
|
|
float pixels[256];
|
||
|
|
float scaled_pixels[256];
|
||
|
|
uint32_t data[4];
|
||
|
|
|
||
|
|
// settings
|
||
|
|
uniform int block_width;
|
||
|
|
uniform int block_height;
|
||
|
|
uniform int pitch;
|
||
|
|
|
||
|
|
uniform int refineIterations;
|
||
|
|
};
|
||
|
|
|
||
|
|
struct astc_enc_context
|
||
|
|
{
|
||
|
|
// uniform parameters
|
||
|
|
int width;
|
||
|
|
int height;
|
||
|
|
int channels;
|
||
|
|
bool dual_plane;
|
||
|
|
int partitions;
|
||
|
|
int color_endpoint_pairs;
|
||
|
|
};
|
||
|
|
|
||
|
|
uniform static const float filter_data[309] =
|
||
|
|
{
|
||
|
|
0.688356,-0.188356, 0.414384, 0.085616, 0.085616, 0.414384,-0.188356, 0.688356,
|
||
|
|
0.955516,-0.227273, 0.044484, 0.142349, 0.727273,-0.142349,-0.142349, 0.727273,
|
||
|
|
0.142349, 0.044484,-0.227273, 0.955516, 0.600000,-0.200000, 0.400000, 0.000000,
|
||
|
|
0.200000, 0.200000, 0.000000, 0.400000,-0.200000, 0.600000, 0.828571,-0.142857,
|
||
|
|
0.028571, 0.342857, 0.285714,-0.057143,-0.142857, 0.714286,-0.142857,-0.057143,
|
||
|
|
0.285714, 0.342857, 0.028571,-0.142857, 0.828571, 0.985714,-0.252381, 0.080952,
|
||
|
|
-0.014286, 0.057143, 1.009524,-0.323810, 0.057143,-0.085714, 0.485714, 0.485714,
|
||
|
|
-0.085714, 0.057143,-0.323810, 1.009524, 0.057143,-0.014286, 0.080952,-0.252381,
|
||
|
|
0.985714, 0.510753,-0.177419, 0.381720,-0.048387, 0.252688, 0.080645, 0.080645,
|
||
|
|
0.252688,-0.048387, 0.381720,-0.177419, 0.510753, 0.754228,-0.194882, 0.052858,
|
||
|
|
0.398312, 0.147638,-0.040044,-0.016924, 0.547244,-0.148431,-0.148431, 0.547244,
|
||
|
|
-0.016924,-0.040044, 0.147638, 0.398312, 0.052858,-0.194882, 0.754228, 0.921235,
|
||
|
|
-0.216677, 0.063615,-0.013072, 0.210040, 0.577804,-0.169641, 0.034858,-0.164122,
|
||
|
|
0.798726,-0.053828, 0.011061, 0.011061,-0.053828, 0.798726,-0.164122, 0.034858,
|
||
|
|
-0.169641, 0.577804, 0.210040,-0.013072, 0.063615,-0.216677, 0.921235, 0.996932,
|
||
|
|
-0.209923, 0.069231,-0.020846, 0.003068, 0.016362, 1.119589,-0.369231, 0.111180,
|
||
|
|
-0.016362,-0.035452, 0.240891, 0.800000,-0.240891, 0.035452, 0.035452,-0.240891,
|
||
|
|
0.800000, 0.240891,-0.035452,-0.016362, 0.111180,-0.369231, 1.119589, 0.016362,
|
||
|
|
0.003068,-0.020846, 0.069231,-0.209923, 0.996932, 0.415909,-0.165909, 0.343182,
|
||
|
|
-0.093182, 0.234091, 0.015909, 0.161364, 0.088636, 0.088636, 0.161364, 0.015909,
|
||
|
|
0.234091,-0.093182, 0.343182,-0.165909, 0.415909, 0.653807,-0.172170, 0.058458,
|
||
|
|
0.395689, 0.040094,-0.013613, 0.189195, 0.209906,-0.071270,-0.068923, 0.422170,
|
||
|
|
-0.143341,-0.143341, 0.422170,-0.068923,-0.071270, 0.209906, 0.189195,-0.013613,
|
||
|
|
0.040094, 0.395689, 0.058458,-0.172170, 0.653807, 0.805363,-0.204713, 0.061406,
|
||
|
|
-0.016387, 0.363455, 0.220460,-0.066129, 0.017647,-0.078453, 0.645632,-0.193664,
|
||
|
|
0.051682,-0.121551, 0.455481, 0.081527,-0.021756,-0.021756, 0.081527, 0.455481,
|
||
|
|
-0.121551, 0.051682,-0.193664, 0.645632,-0.078453, 0.017647,-0.066129, 0.220460,
|
||
|
|
0.363455,-0.016387, 0.061406,-0.204713, 0.805363, 0.881593,-0.204539, 0.075065,
|
||
|
|
-0.021559, 0.004453, 0.270644, 0.467517,-0.171576, 0.049278,-0.010179,-0.169588,
|
||
|
|
0.821023,-0.159819, 0.045902,-0.009481,-0.012311, 0.059603, 0.756331,-0.217226,
|
||
|
|
0.044870, 0.044870,-0.217226, 0.756331, 0.059603,-0.012311,-0.009481, 0.045902,
|
||
|
|
-0.159819, 0.821023,-0.169588,-0.010179, 0.049278,-0.171576, 0.467517, 0.270644,
|
||
|
|
0.004453,-0.021559, 0.075065,-0.204539, 0.881593, 0.967275,-0.287351, 0.076902,
|
||
|
|
-0.018670, 0.005432,-0.000959, 0.104719, 0.919524,-0.246087, 0.059743,-0.017382,
|
||
|
|
0.003067,-0.127990, 0.653915, 0.300773,-0.073019, 0.021245,-0.003749, 0.064956,
|
||
|
|
-0.331864, 1.007366,-0.105833, 0.030792,-0.005434,-0.006723, 0.034349,-0.104266,
|
||
|
|
0.996397,-0.289905, 0.051160,-0.005112, 0.026120,-0.079287, 0.323158, 0.571013,
|
||
|
|
-0.100767, 0.003834,-0.019590, 0.059465,-0.242368, 0.905074, 0.075575,-0.000959,
|
||
|
|
0.004898,-0.014866, 0.060592,-0.226268, 0.981106,
|
||
|
|
};
|
||
|
|
|
||
|
|
uniform static const int filterbank[5][5] =
|
||
|
|
{
|
||
|
|
{ 0, 8, -1, -1, -1 },
|
||
|
|
{ 20, 30, 45, -1, -1 },
|
||
|
|
{ 65, 77, 95, 119, -1 },
|
||
|
|
{ -1, -1, -1, -1, -1 },
|
||
|
|
{ 149, 165, 189, 221, 261 },
|
||
|
|
};
|
||
|
|
|
||
|
|
void scale_pixels(astc_enc_state state[], uniform astc_enc_context ctx[])
|
||
|
|
{
|
||
|
|
uniform int channels = ctx->channels;
|
||
|
|
uniform const float* uniform yfilter = &filter_data[filterbank[state->block_height - 4][ctx->height - 2]];
|
||
|
|
uniform const float* uniform xfilter = &filter_data[filterbank[state->block_width - 4][ctx->width - 2]];
|
||
|
|
|
||
|
|
for (uniform int y = 0; y < ctx->height; y++)
|
||
|
|
{
|
||
|
|
float line[8][4];
|
||
|
|
|
||
|
|
if (state->block_height == ctx->height)
|
||
|
|
{
|
||
|
|
for (uniform int x = 0; x < state->block_width; x++)
|
||
|
|
for (uniform int p = 0; p < channels; p++)
|
||
|
|
line[x][p] = get_pixel(state->pixels, p, x, y);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
for (uniform int x = 0; x < state->block_width; x++)
|
||
|
|
{
|
||
|
|
uniform int n = ctx->height;
|
||
|
|
|
||
|
|
for (uniform int p = 0; p < channels; p++) line[x][p] = 0;
|
||
|
|
|
||
|
|
for (uniform int k = 0; k < state->block_height; k++)
|
||
|
|
for (uniform int p = 0; p < channels; p++)
|
||
|
|
line[x][p] += yfilter[k * n + y] * get_pixel(state->pixels, p, x, k);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (state->block_width == ctx->width)
|
||
|
|
{
|
||
|
|
for (uniform int x = 0; x < ctx->width; x++)
|
||
|
|
for (uniform int p = 0; p < channels; p++)
|
||
|
|
set_pixel(state->scaled_pixels, p, x, y, clamp(line[x][p], 0, 255));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
for (uniform int x = 0; x < ctx->width; x++)
|
||
|
|
{
|
||
|
|
uniform int n = ctx->width;
|
||
|
|
|
||
|
|
float value[4] = { 0, 0, 0, 0 };
|
||
|
|
|
||
|
|
for (uniform int k = 0; k < state->block_width; k++)
|
||
|
|
for (uniform int p = 0; p < channels; p++)
|
||
|
|
value[p] += xfilter[k * n + x] * line[k][p];
|
||
|
|
|
||
|
|
for (uniform int p = 0; p < channels; p++)
|
||
|
|
set_pixel(state->scaled_pixels, p, x, y, clamp(value[p], 0, 255));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
inline int clamp_unorm8(int value)
|
||
|
|
{
|
||
|
|
if (value < 0) return 0;
|
||
|
|
if (value > 255) return 255;
|
||
|
|
return value;
|
||
|
|
}
|
||
|
|
|
||
|
|
inline void apply_blue_contract(int& r, int& g, int& b)
|
||
|
|
{
|
||
|
|
r = (r + b) >> 1;
|
||
|
|
g = (g + b) >> 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
void decode_endpoints(float endpoints[8], uint8_t coded_endpoints[], int mode)
|
||
|
|
{
|
||
|
|
if ((mode % 4) == 2)
|
||
|
|
{
|
||
|
|
int v0 = coded_endpoints[0];
|
||
|
|
int v1 = coded_endpoints[1];
|
||
|
|
int v2 = coded_endpoints[2];
|
||
|
|
int v3 = coded_endpoints[3];
|
||
|
|
int v4 = coded_endpoints[4];
|
||
|
|
int v5 = coded_endpoints[5];
|
||
|
|
|
||
|
|
endpoints[0] = (v0 * v3) >> 8;
|
||
|
|
endpoints[1] = (v1 * v3) >> 8;
|
||
|
|
endpoints[2] = (v2 * v3) >> 8;
|
||
|
|
endpoints[3] = 0xFF;
|
||
|
|
|
||
|
|
endpoints[4] = v0;
|
||
|
|
endpoints[5] = v1;
|
||
|
|
endpoints[6] = v2;
|
||
|
|
endpoints[7] = 0xFF;
|
||
|
|
|
||
|
|
if (mode > 8)
|
||
|
|
{
|
||
|
|
endpoints[3] = clamp_unorm8(v4);
|
||
|
|
endpoints[7] = clamp_unorm8(v5);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if ((mode % 4) == 0)
|
||
|
|
{
|
||
|
|
int v0 = coded_endpoints[0];
|
||
|
|
int v1 = coded_endpoints[1];
|
||
|
|
int v2 = coded_endpoints[2];
|
||
|
|
int v3 = coded_endpoints[3];
|
||
|
|
int v4 = coded_endpoints[4];
|
||
|
|
int v5 = coded_endpoints[5];
|
||
|
|
int v6 = coded_endpoints[6];
|
||
|
|
int v7 = coded_endpoints[7];
|
||
|
|
|
||
|
|
bool swap_endpoints = v1 + v3 + v5 < v0 + v2 + v4;
|
||
|
|
|
||
|
|
if (swap_endpoints)
|
||
|
|
{
|
||
|
|
swap(v0, v1);
|
||
|
|
swap(v2, v3);
|
||
|
|
swap(v4, v5);
|
||
|
|
swap(v6, v7);
|
||
|
|
|
||
|
|
apply_blue_contract(v0, v2, v4);
|
||
|
|
apply_blue_contract(v1, v3, v5);
|
||
|
|
}
|
||
|
|
|
||
|
|
endpoints[0] = clamp_unorm8(v0);
|
||
|
|
endpoints[1] = clamp_unorm8(v2);
|
||
|
|
endpoints[2] = clamp_unorm8(v4);
|
||
|
|
endpoints[3] = 0xFF;
|
||
|
|
|
||
|
|
endpoints[4] = clamp_unorm8(v1);
|
||
|
|
endpoints[5] = clamp_unorm8(v3);
|
||
|
|
endpoints[6] = clamp_unorm8(v5);
|
||
|
|
endpoints[7] = 0xFF;
|
||
|
|
|
||
|
|
if (mode > 8)
|
||
|
|
{
|
||
|
|
endpoints[3] = clamp_unorm8(v6);
|
||
|
|
endpoints[7] = clamp_unorm8(v7);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void dequant_decode_endpoints(float endpoints[8], uint8_t block_endpoints[], int mode, int range)
|
||
|
|
{
|
||
|
|
int levels = get_levels(range);
|
||
|
|
int num_cem_pairs = 1 + mode / 4;
|
||
|
|
|
||
|
|
uint8_t dequant_endpoints[8];
|
||
|
|
for (uniform int k = 0; k < 2 * num_cem_pairs; k++)
|
||
|
|
{
|
||
|
|
dequant_endpoints[k] = (int)(((int)block_endpoints[k]) * 255.0f / (levels - 1) + 0.5);
|
||
|
|
}
|
||
|
|
|
||
|
|
decode_endpoints(endpoints, dequant_endpoints, mode);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool compare_endpoints(uint8_t endpoints[8], astc_block block[])
|
||
|
|
{
|
||
|
|
int sum = 0;
|
||
|
|
for (uniform int p = 0; p < 3; p++)
|
||
|
|
{
|
||
|
|
sum += endpoints[p * 2 + 0];
|
||
|
|
sum -= endpoints[p * 2 + 1];
|
||
|
|
}
|
||
|
|
|
||
|
|
if (-2 <= sum && sum <= 2)
|
||
|
|
{
|
||
|
|
// avoid being too close so we don't need proper rounding
|
||
|
|
for (uniform int p = 0; p < 3; p++)
|
||
|
|
{
|
||
|
|
if (sum<=0)
|
||
|
|
endpoints[p * 2 + 0] = clamp(endpoints[p * 2 + 0] - 1, 0, get_levels(block->endpoint_range) - 1);
|
||
|
|
if (sum>0)
|
||
|
|
endpoints[p * 2 + 1] = clamp(endpoints[p * 2 + 1] - 1, 0, get_levels(block->endpoint_range) - 1);
|
||
|
|
}
|
||
|
|
|
||
|
|
sum = 0;
|
||
|
|
for (uniform int p = 0; p < 3; p++)
|
||
|
|
{
|
||
|
|
sum += endpoints[p * 2 + 0];
|
||
|
|
sum -= endpoints[p * 2 + 1];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return sum > 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
void reorder_endpoints(uint8_t endpoints[8], astc_block block[], bool blue_contract)
|
||
|
|
{
|
||
|
|
if (compare_endpoints(endpoints, block) == !blue_contract)
|
||
|
|
for (uniform int p = 0; p < 4; p++) swap(endpoints[p * 2], endpoints[p * 2 + 1]);
|
||
|
|
}
|
||
|
|
|
||
|
|
inline int quant_endpoint(float value, int levels)
|
||
|
|
{
|
||
|
|
return clamp(value / 255.0f * (levels - 1) + 0.5, 0, levels - 1);
|
||
|
|
}
|
||
|
|
|
||
|
|
void quantize_endpoints_scale(astc_block block[], float endpoints[4])
|
||
|
|
{
|
||
|
|
int ep_levels = get_levels(block->endpoint_range);
|
||
|
|
|
||
|
|
float near[3];
|
||
|
|
float far[3];
|
||
|
|
for (uniform int p = 0; p < 3; p++)
|
||
|
|
{
|
||
|
|
near[p] = endpoints[p * 2 + 0];
|
||
|
|
far[p] = endpoints[p * 2 + 1];
|
||
|
|
}
|
||
|
|
|
||
|
|
for (uniform int p = 0; p < 3; p++)
|
||
|
|
block->endpoints[p] = quant_endpoint(far[p], ep_levels);
|
||
|
|
|
||
|
|
float sq_norm = dot3(far, far) + 0.00001;
|
||
|
|
float scale = dot3(far, near) / sq_norm;
|
||
|
|
|
||
|
|
block->endpoints[3] = quant_endpoint(scale * 256, ep_levels);
|
||
|
|
|
||
|
|
if (block->color_endpoint_modes[0] > 8)
|
||
|
|
{
|
||
|
|
block->endpoints[4] = quant_endpoint(endpoints[3 * 2 + 0], ep_levels);
|
||
|
|
block->endpoints[5] = quant_endpoint(endpoints[3 * 2 + 1], ep_levels);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void quantize_endpoints_pair(astc_block block[], float endpoints[6])
|
||
|
|
{
|
||
|
|
int ep_levels = get_levels(block->endpoint_range);
|
||
|
|
|
||
|
|
bool blue_contract = true;
|
||
|
|
|
||
|
|
float blue_compressed[6];
|
||
|
|
for (uniform int i = 0; i < 2; i++)
|
||
|
|
{
|
||
|
|
blue_compressed[i + 0] = endpoints[i + 0] * 2 - endpoints[i + 4];
|
||
|
|
blue_compressed[i + 2] = endpoints[i + 2] * 2 - endpoints[i + 4];
|
||
|
|
blue_compressed[i + 4] = endpoints[i + 4];
|
||
|
|
|
||
|
|
if (blue_compressed[i + 0] < 0) blue_contract = false;
|
||
|
|
if (blue_compressed[i + 0] > 255) blue_contract = false;
|
||
|
|
if (blue_compressed[i + 2] < 0) blue_contract = false;
|
||
|
|
if (blue_compressed[i + 2] > 255) blue_contract = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (blue_contract)
|
||
|
|
{
|
||
|
|
for (uniform int p = 0; p < 3; p++)
|
||
|
|
{
|
||
|
|
block->endpoints[p * 2 + 0] = quant_endpoint(blue_compressed[p * 2 + 0], ep_levels);
|
||
|
|
block->endpoints[p * 2 + 1] = quant_endpoint(blue_compressed[p * 2 + 1], ep_levels);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
for (uniform int p = 0; p < 3; p++)
|
||
|
|
{
|
||
|
|
block->endpoints[p * 2 + 0] = quant_endpoint(endpoints[p * 2 + 0], ep_levels);
|
||
|
|
block->endpoints[p * 2 + 1] = quant_endpoint(endpoints[p * 2 + 1], ep_levels);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (block->color_endpoint_modes[0] > 8)
|
||
|
|
{
|
||
|
|
block->endpoints[6] = quant_endpoint(endpoints[3 * 2 + 0], ep_levels);
|
||
|
|
block->endpoints[7] = quant_endpoint(endpoints[3 * 2 + 1], ep_levels);
|
||
|
|
}
|
||
|
|
|
||
|
|
reorder_endpoints(block->endpoints, block, blue_contract);
|
||
|
|
}
|
||
|
|
|
||
|
|
void quantize_endpoints(astc_block block[], float endpoints[])
|
||
|
|
{
|
||
|
|
bool zero_based = (block->color_endpoint_modes[0] % 4) == 2;
|
||
|
|
|
||
|
|
if (zero_based)
|
||
|
|
{
|
||
|
|
quantize_endpoints_scale(block, endpoints);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
quantize_endpoints_pair(block, endpoints);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void opt_weights(float scaled_pixels[], astc_block block[])
|
||
|
|
{
|
||
|
|
uniform int channels = 4;
|
||
|
|
if (block->dual_plane) channels = 3;
|
||
|
|
|
||
|
|
float rec_endpoints[8];
|
||
|
|
dequant_decode_endpoints(rec_endpoints, block->endpoints, block->color_endpoint_modes[0], block->endpoint_range);
|
||
|
|
|
||
|
|
int w_levels = get_levels(block->weight_range);
|
||
|
|
|
||
|
|
float dir[4]; dir[3] = 0;
|
||
|
|
for (uniform int p = 0; p < channels; p++) dir[p] = rec_endpoints[4 + p] - rec_endpoints[0 + p];
|
||
|
|
float sq_norm = dot4(dir, dir) + 0.00001;
|
||
|
|
for (uniform int p = 0; p < channels; p++) dir[p] *= (w_levels - 1) / sq_norm;
|
||
|
|
|
||
|
|
for (uniform int y = 0; y < block->height; y++)
|
||
|
|
for (uniform int x = 0; x < block->width; x++)
|
||
|
|
{
|
||
|
|
float pixel[4]; pixel[3] = 0;
|
||
|
|
for (uniform int p = 0; p < channels; p++) pixel[p] = get_pixel(scaled_pixels, p, x, y) - rec_endpoints[0 + p];
|
||
|
|
|
||
|
|
int q = clamp(dot4(pixel, dir) + 0.5, 0, w_levels - 1);
|
||
|
|
|
||
|
|
block->weights[y * block->width + x] = q;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
bool sgesv2(float A[4], float x[2], float b[2])
|
||
|
|
{
|
||
|
|
float det = (A[0] * A[3] - A[1] * A[2]);
|
||
|
|
if(det == 0)
|
||
|
|
return false;
|
||
|
|
float inv_det = 1.0f / det;
|
||
|
|
x[0] = (b[0] * +A[3] + b[1] * -A[2])*inv_det;
|
||
|
|
x[1] = (b[0] * -A[1] + b[1] * +A[0])*inv_det;
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
void ls_refine_scale(float endpoints[8], float scaled_pixels[], astc_block block[])
|
||
|
|
{
|
||
|
|
int levels = get_levels(block->weight_range);
|
||
|
|
float levels_rcp = 1.0f / (levels - 1);
|
||
|
|
|
||
|
|
// In this mode, the endpoints are on a line through 0, and the first endpoint
|
||
|
|
// is a scaled version of the second endpoint with a scale factor 0 <= s < 1.
|
||
|
|
//
|
||
|
|
// Determining optimal s and endpoints is a non-linear problem; approximate it
|
||
|
|
// by first solving for the scale factor and then separately solving for the
|
||
|
|
// endpoint value.
|
||
|
|
//
|
||
|
|
// The scale factor solve starts from (where e_0, e_1 are RGB endpoints)
|
||
|
|
// e_0 = s * e_1
|
||
|
|
//
|
||
|
|
// thus for an interpolation weight w
|
||
|
|
// lerp(e_0, e_1, w)
|
||
|
|
// = lerp(s * e_1, e_1, w)
|
||
|
|
// = lerp(s, 1, w) * e_1
|
||
|
|
// = (s + (1-s)*w) * e_1
|
||
|
|
//
|
||
|
|
// and if we take look at the 2-norm (Euclidean length) of that vector
|
||
|
|
//
|
||
|
|
// len(lerp(e_0, e_1, w)) = (s + (1-s)*w) * len(e_1)
|
||
|
|
//
|
||
|
|
// if we consider s and (1-s) as separate unknowns xx_0 and xx_1, we get
|
||
|
|
// an overdetermined linear system for the 2D vector lengths of the pixels
|
||
|
|
// (d_i in the following) that we can solve in a Least-Squares sense via
|
||
|
|
// the Normal Equations and Cramer's rule:
|
||
|
|
//
|
||
|
|
// [1 w_1] [d_1]
|
||
|
|
// [1 w_2] [xx_0] [d_2]
|
||
|
|
// [1 w_3] [xx_1] = [d_3]
|
||
|
|
// [ ... ] [...]
|
||
|
|
// [1 w_N] [d_N]
|
||
|
|
//
|
||
|
|
// we then recover s (the ratio between the lengths of e_0 and e_1) as
|
||
|
|
// xx_0 / (xx_0 + xx_1).
|
||
|
|
float sum_w = 0;
|
||
|
|
float sum_ww = 0;
|
||
|
|
float sum_d = 0;
|
||
|
|
float sum_wd = 0;
|
||
|
|
|
||
|
|
for (uniform int y = 0; y < block->height; y++)
|
||
|
|
for (uniform int x = 0; x < block->width; x++)
|
||
|
|
{
|
||
|
|
float w = (int)block->weights[y * block->width + x] * levels_rcp;
|
||
|
|
float d = 0;
|
||
|
|
|
||
|
|
for (uniform int p = 0; p < 3; p++) d += sq(get_pixel(scaled_pixels, p, x, y));
|
||
|
|
d = sqrt(d+0.01f);
|
||
|
|
|
||
|
|
sum_w += w;
|
||
|
|
sum_ww += w*w;
|
||
|
|
sum_d += d;
|
||
|
|
sum_wd += w*d;
|
||
|
|
}
|
||
|
|
|
||
|
|
float sum_1 = 1.0f * block->height * block->width;
|
||
|
|
|
||
|
|
float C[4] = { sum_1, sum_w, sum_w, sum_ww };
|
||
|
|
float b[2] = { sum_d, sum_wd };
|
||
|
|
float xx[2];
|
||
|
|
|
||
|
|
// Singular configurations are precisely those where all weights are equal, i.e. constant color.
|
||
|
|
// Used to set scale=0 in this case but that's really bad when that weight is 0 (we're now making
|
||
|
|
// the whole block black). scale=1 isn't ideal (and in fact not something we can hit exactly)
|
||
|
|
// but at least leaves the endpoints in roughly the right place.
|
||
|
|
float scale = 1;
|
||
|
|
if(sgesv2(C, xx, b))
|
||
|
|
{
|
||
|
|
scale = xx[0] / (xx[1] + xx[0]);
|
||
|
|
if (xx[1] + xx[0] < 1) scale = 1;
|
||
|
|
scale = clamp(scale, 0.0f, 0.9999f); // note: clamp also takes care of possible NaNs
|
||
|
|
}
|
||
|
|
|
||
|
|
// Now, solve another Least Squares system for the actual endpoint values given the previously
|
||
|
|
// determined scale. This time we're trying to solve, for every pixel p_i
|
||
|
|
//
|
||
|
|
// p_i = lerp(e_0, e_1, w) = (s + (1-s)*w_i) * e_1
|
||
|
|
//
|
||
|
|
// let z_i := s + (1 - s)*w_i, then we get the overdetermined linear system
|
||
|
|
//
|
||
|
|
// [z_1] [p_1^T]
|
||
|
|
// [z_2] [p_2^T]
|
||
|
|
// [z_3] [e_1]^T = [p_3^T]
|
||
|
|
// [...] [ ... ]
|
||
|
|
// [z_N] [p_N^T]
|
||
|
|
//
|
||
|
|
// which we solve in a least-squares sense for e_1.
|
||
|
|
float sum_zz = 0;
|
||
|
|
float sum_zp[3] = { 0, 0, 0 };
|
||
|
|
|
||
|
|
for (uniform int y = 0; y < block->height; y++)
|
||
|
|
for (uniform int x = 0; x < block->width; x++)
|
||
|
|
{
|
||
|
|
float w = (int)block->weights[y * block->width + x] * levels_rcp;
|
||
|
|
float z = scale + (1 - scale)*w;
|
||
|
|
|
||
|
|
sum_zz += z * z;
|
||
|
|
for (uniform int p = 0; p < 3; p++) sum_zp[p] += z * get_pixel(scaled_pixels, p, x, y);
|
||
|
|
}
|
||
|
|
|
||
|
|
for (uniform int p = 0; p < 3; p++) endpoints[2 * p + 0] = scale * sum_zp[p] / sum_zz;
|
||
|
|
for (uniform int p = 0; p < 3; p++) endpoints[2 * p + 1] = sum_zp[p] / sum_zz;
|
||
|
|
|
||
|
|
if (block->channels == 4)
|
||
|
|
{
|
||
|
|
float Atb1 = 0;
|
||
|
|
float sum_q = 0;
|
||
|
|
float sum_qq = 0;
|
||
|
|
float sum[2] = { 0, 0 };
|
||
|
|
|
||
|
|
for (uniform int y = 0; y < block->height; y++)
|
||
|
|
for (uniform int x = 0; x < block->width; x++)
|
||
|
|
{
|
||
|
|
int q = block->weights[y * block->width + x];
|
||
|
|
int z = (levels - 1) - q;
|
||
|
|
|
||
|
|
sum_q += q;
|
||
|
|
sum_qq += q*q;
|
||
|
|
|
||
|
|
sum[1] += 1;
|
||
|
|
sum[0] += get_pixel(scaled_pixels, 3, x, y);
|
||
|
|
Atb1 += z * get_pixel(scaled_pixels, 3, x, y);
|
||
|
|
}
|
||
|
|
|
||
|
|
float Atb2 = (levels - 1)*sum[0] - Atb1;
|
||
|
|
|
||
|
|
float Cxx = sum[1] * sq(levels - 1) - 2 * (levels - 1)*sum_q + sum_qq;
|
||
|
|
float Cyy = sum_qq;
|
||
|
|
float Cxy = (levels - 1)*sum_q - sum_qq;
|
||
|
|
float scale = 1.0f / (Cxx*Cyy - Cxy*Cxy);
|
||
|
|
|
||
|
|
float ep[8];
|
||
|
|
ep[0 + 3] = (levels - 1)*(Atb1 * Cyy - Atb2 * Cxy)*scale;
|
||
|
|
ep[4 + 3] = (levels - 1)*(Atb2 * Cxx - Atb1 * Cxy)*scale;
|
||
|
|
|
||
|
|
if (abs(Cxx*Cyy - Cxy*Cxy) < 0.001)
|
||
|
|
{
|
||
|
|
ep[0 + 3] = sum[0] / sum[1];
|
||
|
|
ep[4 + 3] = ep[0 + 3];
|
||
|
|
}
|
||
|
|
|
||
|
|
endpoints[6 + 0] = ep[0 + 3];
|
||
|
|
endpoints[6 + 1] = ep[4 + 3];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void ls_refine_pair(float endpoints[6], float scaled_pixels[], astc_block block[])
|
||
|
|
{
|
||
|
|
uniform int channels = block->channels;
|
||
|
|
int levels = get_levels(block->weight_range);
|
||
|
|
|
||
|
|
float Atb1[4] = { 0, 0, 0, 0 };
|
||
|
|
float sum_q = 0;
|
||
|
|
float sum_qq = 0;
|
||
|
|
float sum[5] = { 0, 0, 0, 0, 0 };
|
||
|
|
|
||
|
|
for (uniform int y = 0; y < block->height; y++)
|
||
|
|
for (uniform int x = 0; x < block->width; x++)
|
||
|
|
{
|
||
|
|
int q = block->weights[y * block->width + x];
|
||
|
|
|
||
|
|
int z = (levels - 1) - q;
|
||
|
|
|
||
|
|
sum_q += q;
|
||
|
|
sum_qq += q*q;
|
||
|
|
|
||
|
|
sum[4] += 1;
|
||
|
|
for (uniform int p = 0; p < channels; p++) sum[p] += get_pixel(scaled_pixels, p, x, y);
|
||
|
|
for (uniform int p = 0; p < channels; p++) Atb1[p] += z * get_pixel(scaled_pixels, p, x, y);
|
||
|
|
}
|
||
|
|
|
||
|
|
float Atb2[4];
|
||
|
|
for (uniform int p = 0; p < channels; p++)
|
||
|
|
{
|
||
|
|
Atb2[p] = (levels - 1)*sum[p] - Atb1[p];
|
||
|
|
}
|
||
|
|
|
||
|
|
float Cxx = sum[4] * sq(levels - 1) - 2 * (levels - 1)*sum_q + sum_qq;
|
||
|
|
float Cyy = sum_qq;
|
||
|
|
float Cxy = (levels - 1)*sum_q - sum_qq;
|
||
|
|
float scale = 1.0f / (Cxx*Cyy - Cxy*Cxy);
|
||
|
|
|
||
|
|
float ep[8];
|
||
|
|
for (uniform int p = 0; p < channels; p++)
|
||
|
|
{
|
||
|
|
ep[0 + p] = (levels - 1)*(Atb1[p] * Cyy - Atb2[p] * Cxy)*scale;
|
||
|
|
ep[4 + p] = (levels - 1)*(Atb2[p] * Cxx - Atb1[p] * Cxy)*scale;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (abs(Cxx*Cyy - Cxy*Cxy) < 0.001)
|
||
|
|
{
|
||
|
|
// flatten
|
||
|
|
for (int p = 0; p < channels; p++)
|
||
|
|
{
|
||
|
|
ep[0 + p] = sum[p] / sum[4];
|
||
|
|
ep[4 + p] = ep[0 + p];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
for (uniform int p = 0; p < channels; p++)
|
||
|
|
{
|
||
|
|
endpoints[2 * p + 0] = ep[0 + p];
|
||
|
|
endpoints[2 * p + 1] = ep[4 + p];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void ls_refine(float endpoints[], float scaled_pixels[], astc_block block[])
|
||
|
|
{
|
||
|
|
if (block->color_endpoint_modes[0] % 4 == 2)
|
||
|
|
{
|
||
|
|
ls_refine_scale(endpoints, scaled_pixels, block);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
ls_refine_pair(endpoints, scaled_pixels, block);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
float optimize_alt_plane(uint8_t alt_weights[], float scaled_pixels[], astc_block block[])
|
||
|
|
{
|
||
|
|
int ccs = block->color_component_selector;
|
||
|
|
|
||
|
|
float ext[2] = { 1000, -1000 };
|
||
|
|
|
||
|
|
for (uniform int y = 0; y < block->height; y++)
|
||
|
|
for (uniform int x = 0; x < block->width; x++)
|
||
|
|
{
|
||
|
|
float value = get_pixel(scaled_pixels, 3, x, y);
|
||
|
|
ext[0] = min(ext[0], value);
|
||
|
|
ext[1] = max(ext[1], value);
|
||
|
|
}
|
||
|
|
|
||
|
|
block->endpoints[3 * 2 + 0] = 0;
|
||
|
|
block->endpoints[3 * 2 + 1] = 255;
|
||
|
|
|
||
|
|
float _rec_endpoints[8];
|
||
|
|
dequant_decode_endpoints(_rec_endpoints, block->endpoints, block->color_endpoint_modes[0], block->endpoint_range);
|
||
|
|
|
||
|
|
float endpoints[8];
|
||
|
|
for (int p = 0; p < 3; p++)
|
||
|
|
{
|
||
|
|
endpoints[p * 2 + 0] = _rec_endpoints[0 + p];
|
||
|
|
endpoints[p * 2 + 1] = _rec_endpoints[4 + p];
|
||
|
|
}
|
||
|
|
|
||
|
|
endpoints[3 * 2 + 0] = gather_float(endpoints, ccs * 2 + 0);
|
||
|
|
endpoints[3 * 2 + 1] = gather_float(endpoints, ccs * 2 + 1);
|
||
|
|
|
||
|
|
scatter_float(endpoints, ccs * 2 + 0, ext[0]);
|
||
|
|
scatter_float(endpoints, ccs * 2 + 1, ext[1]);
|
||
|
|
|
||
|
|
quantize_endpoints(block, endpoints);
|
||
|
|
|
||
|
|
float rec_endpoints[8];
|
||
|
|
dequant_decode_endpoints(rec_endpoints, block->endpoints, block->color_endpoint_modes[0], block->endpoint_range);
|
||
|
|
|
||
|
|
float base = gather_float(rec_endpoints, 0 + ccs);
|
||
|
|
float dir = gather_float(rec_endpoints, 4 + ccs) - base;
|
||
|
|
float sq_norm = sq(dir) + 0.00001;
|
||
|
|
|
||
|
|
int w_levels = get_levels(block->weight_range);
|
||
|
|
dir *= (w_levels - 1) / sq_norm;
|
||
|
|
|
||
|
|
float err = 0;
|
||
|
|
for (uniform int y = 0; y < block->height; y++)
|
||
|
|
for (uniform int x = 0; x < block->width; x++)
|
||
|
|
{
|
||
|
|
float value = get_pixel(scaled_pixels, 3, x, y) - base;
|
||
|
|
|
||
|
|
int q = clamp(value * dir + 0.5, 0, w_levels - 1);
|
||
|
|
|
||
|
|
alt_weights[y * block->width + x] = q;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (dir < 0)
|
||
|
|
for (uniform int y = 0; y < block->height; y++)
|
||
|
|
for (uniform int x = 0; x < block->width; x++)
|
||
|
|
{
|
||
|
|
int q = block->weights[y * block->width + x];
|
||
|
|
|
||
|
|
block->weights[y * block->width + x] = w_levels - 1 - q;
|
||
|
|
}
|
||
|
|
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
void optimize_block(float scaled_pixels[], astc_block block[], astc_enc_state state[])
|
||
|
|
{
|
||
|
|
pixel_set pset;
|
||
|
|
pset.pixels = scaled_pixels;
|
||
|
|
pset.width = block->width;
|
||
|
|
pset.height = block->height;
|
||
|
|
|
||
|
|
float ep[8];
|
||
|
|
bool zero_based = (block->color_endpoint_modes[0] % 4) == 2;
|
||
|
|
compute_pca_endpoints(ep, &pset, zero_based, 4);
|
||
|
|
|
||
|
|
quantize_endpoints(block, ep);
|
||
|
|
opt_weights(scaled_pixels, block);
|
||
|
|
|
||
|
|
for (uniform int i = 0; i < state->refineIterations; i++)
|
||
|
|
{
|
||
|
|
ls_refine(ep, scaled_pixels, block);
|
||
|
|
quantize_endpoints(block, ep);
|
||
|
|
opt_weights(scaled_pixels, block);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (block->dual_plane)
|
||
|
|
{
|
||
|
|
uint8_t alt_weights[64];
|
||
|
|
optimize_alt_plane(alt_weights, scaled_pixels, block);
|
||
|
|
|
||
|
|
uint8_t block_weights[64];
|
||
|
|
for (uniform int i = 0; i < block->width * block->height; i++)
|
||
|
|
{
|
||
|
|
block_weights[i] = block->weights[i];
|
||
|
|
}
|
||
|
|
|
||
|
|
for (uniform int i = 0; i < block->width * block->height; i++)
|
||
|
|
{
|
||
|
|
block->weights[i * 2 + 0] = block_weights[i];
|
||
|
|
block->weights[i * 2 + 1] = alt_weights[i];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
float measure_error(astc_block block[], astc_enc_state state[])
|
||
|
|
{
|
||
|
|
uniform int pitch = state->block_height * state->block_width;
|
||
|
|
assert(pitch <= 64);
|
||
|
|
|
||
|
|
// dequant values
|
||
|
|
uniform int num_weights = block->width * block->height * (block->dual_plane ? 2 : 1);
|
||
|
|
|
||
|
|
range_values weight_range_values = get_range_values(block->weight_range);
|
||
|
|
|
||
|
|
int block_weights[64];
|
||
|
|
for (int i = 0; i < num_weights; i++)
|
||
|
|
{
|
||
|
|
block_weights[i] = ((int)block->weights[i] * 64.0f / (weight_range_values.levels - 1) + 0.5);
|
||
|
|
}
|
||
|
|
|
||
|
|
float rgba_endpoints[8];
|
||
|
|
dequant_decode_endpoints(rgba_endpoints, block->endpoints, block->color_endpoint_modes[0], block->endpoint_range);
|
||
|
|
|
||
|
|
uniform int stride = block->width;
|
||
|
|
uniform int Ds = (1024 + state->block_width / 2) / (state->block_width - 1);
|
||
|
|
uniform int Dt = (1024 + state->block_height / 2) / (state->block_height - 1);
|
||
|
|
|
||
|
|
uint8_t main_weights[64];
|
||
|
|
uint8_t alt_weights[64];
|
||
|
|
|
||
|
|
for (uniform int i = 0; i < num_weights; i++) main_weights[i] = block_weights[i];
|
||
|
|
|
||
|
|
if (block->dual_plane)
|
||
|
|
for (uniform int i = 0; i < num_weights/2; i++)
|
||
|
|
{
|
||
|
|
main_weights[i] = block_weights[i * 2 + 0];
|
||
|
|
alt_weights[i] = block_weights[i * 2 + 1];
|
||
|
|
}
|
||
|
|
|
||
|
|
float sq_error = 0;
|
||
|
|
|
||
|
|
for (uniform int y = 0; y < state->block_height; y++)
|
||
|
|
for (uniform int x = 0; x < state->block_width; x++)
|
||
|
|
{
|
||
|
|
uniform int gs = (x * Ds * (block->width - 1) + 32) >> 6;
|
||
|
|
uniform int gt = (y * Dt * (block->height - 1) + 32) >> 6;
|
||
|
|
|
||
|
|
uniform int js = gs >> 4;
|
||
|
|
uniform int jt = gt >> 4;
|
||
|
|
|
||
|
|
uniform int fs = gs & 0x0F;
|
||
|
|
uniform int ft = gt & 0x0F;
|
||
|
|
uniform int w11 = ((fs*ft + 8) >> 4);
|
||
|
|
|
||
|
|
int filled_weight = 0;
|
||
|
|
int alt_filled_weight = 0;
|
||
|
|
|
||
|
|
{
|
||
|
|
int acc = 0;
|
||
|
|
acc += main_weights[stride * (jt + 0) + js + 0] * (16 - ft - fs + w11);
|
||
|
|
acc += main_weights[stride * (jt + 0) + js + 1] * (fs - w11);
|
||
|
|
acc += main_weights[stride * (jt + 1) + js + 0] * (ft - w11);
|
||
|
|
acc += main_weights[stride * (jt + 1) + js + 1] * w11;
|
||
|
|
filled_weight = (acc + 8) >> 4;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (block->dual_plane)
|
||
|
|
{
|
||
|
|
int acc = 0;
|
||
|
|
acc += alt_weights[stride * (jt + 0) + js + 0] * (16 - ft - fs + w11);
|
||
|
|
acc += alt_weights[stride * (jt + 0) + js + 1] * (fs - w11);
|
||
|
|
acc += alt_weights[stride * (jt + 1) + js + 0] * (ft - w11);
|
||
|
|
acc += alt_weights[stride * (jt + 1) + js + 1] * w11;
|
||
|
|
alt_filled_weight = (acc + 8) >> 4;
|
||
|
|
}
|
||
|
|
|
||
|
|
for (uniform int p = 0; p < block->channels; p++)
|
||
|
|
{
|
||
|
|
int C0 = rgba_endpoints[0 + p] * 256 + 128;
|
||
|
|
int C1 = rgba_endpoints[4 + p] * 256 + 128;
|
||
|
|
int w = filled_weight;
|
||
|
|
|
||
|
|
if (block->dual_plane && block->color_component_selector == p)
|
||
|
|
{
|
||
|
|
w = alt_filled_weight;
|
||
|
|
}
|
||
|
|
|
||
|
|
int C = (C0 * (64 - w) + C1 * w + 32) / 64;
|
||
|
|
|
||
|
|
float diff = (C >> 8) - get_pixel(state->pixels, p, x, y);
|
||
|
|
sq_error += diff * diff;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return sq_error;
|
||
|
|
}
|
||
|
|
|
||
|
|
int code_value(int value, range_values range)
|
||
|
|
{
|
||
|
|
int coded = value;
|
||
|
|
|
||
|
|
if (range.levels_m != 2 && range.levels > 5)
|
||
|
|
{
|
||
|
|
int value2 = value;
|
||
|
|
if (value >= range.levels / 2) value2 = (range.levels - 1) - value;
|
||
|
|
int q = (value2 * range.levels_m_rcp) >> 16;
|
||
|
|
int r = value2 - q * range.levels_m;
|
||
|
|
coded = q + r * (1 << (range.levels_e - 1));
|
||
|
|
coded = coded * 2 + ((value >= range.levels / 2) ? 1 : 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
return coded;
|
||
|
|
}
|
||
|
|
|
||
|
|
void code_block(astc_block block[])
|
||
|
|
{
|
||
|
|
uniform int num_weights = block->width * block->height * (block->dual_plane ? 2 : 1);
|
||
|
|
|
||
|
|
range_values weight_range_values = get_range_values(block->weight_range);
|
||
|
|
for (uniform int i = 0; i < num_weights; i++)
|
||
|
|
{
|
||
|
|
block->weights[i] = code_value(block->weights[i], weight_range_values);
|
||
|
|
}
|
||
|
|
|
||
|
|
range_values endpoint_range_values = get_range_values(block->endpoint_range);
|
||
|
|
for (uniform int i = 0; i < 2 * block->color_endpoint_pairs; i++)
|
||
|
|
{
|
||
|
|
block->endpoints[i] = code_value(block->endpoints[i], endpoint_range_values);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
extern "C" void pack_block_c(uniform uint32_t data[4], uniform astc_block block[]);
|
||
|
|
|
||
|
|
void pack_block(astc_block block[], astc_enc_state state[])
|
||
|
|
{
|
||
|
|
code_block(block);
|
||
|
|
|
||
|
|
foreach_active (instance)
|
||
|
|
{
|
||
|
|
uniform astc_block ublock;
|
||
|
|
|
||
|
|
ublock.width = block->width;
|
||
|
|
ublock.height = block->height;
|
||
|
|
ublock.dual_plane = block->dual_plane;
|
||
|
|
ublock.partitions = block->partitions;
|
||
|
|
ublock.color_endpoint_pairs = block->color_endpoint_pairs;
|
||
|
|
|
||
|
|
ublock.weight_range = extract(block->weight_range, instance);
|
||
|
|
ublock.color_component_selector = extract(block->color_component_selector, instance);
|
||
|
|
ublock.partition_id = extract(block->partition_id, instance);
|
||
|
|
ublock.endpoint_range = extract(block->endpoint_range, instance);
|
||
|
|
ublock.color_endpoint_modes[0] = extract(block->color_endpoint_modes[0], instance);
|
||
|
|
|
||
|
|
uniform int num_weights = block->width * block->height * (block->dual_plane ? 2 : 1);
|
||
|
|
for (uniform int i = 0; i < num_weights; i++)
|
||
|
|
ublock.weights[i] = extract(block->weights[i], instance);
|
||
|
|
|
||
|
|
for (uniform int i = 0; i < 8; i++)
|
||
|
|
ublock.endpoints[i] = extract(block->endpoints[i], instance);
|
||
|
|
|
||
|
|
uniform uint32_t data[4];
|
||
|
|
pack_block_c(data, &ublock);
|
||
|
|
|
||
|
|
for (uniform int i = 0; i < 4; i++) state->data[i] = insert(state->data[i], instance, data[i]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
int get_bits(uint32_t value, uniform int from, uniform int to)
|
||
|
|
{
|
||
|
|
return (value >> from) & ((1 << (to + 1 - from)) - 1);
|
||
|
|
}
|
||
|
|
|
||
|
|
void load_block_parameters(astc_block block[], uint32_t mode, uniform astc_enc_context ctx[])
|
||
|
|
{
|
||
|
|
// uniform parameters
|
||
|
|
block->width = ctx->width;
|
||
|
|
block->height = ctx->height;
|
||
|
|
block->dual_plane = ctx->dual_plane;
|
||
|
|
block->partitions = ctx->partitions;
|
||
|
|
block->color_endpoint_pairs = ctx->color_endpoint_pairs;
|
||
|
|
block->channels = ctx->channels;
|
||
|
|
|
||
|
|
// varying parameters
|
||
|
|
block->weight_range = get_bits(mode, 0, 3); // 0..11 <= 2^4
|
||
|
|
block->color_component_selector = get_bits(mode, 4, 5); // 0..2 <= 2^2
|
||
|
|
block->partition_id = 0;
|
||
|
|
block->color_endpoint_modes[0] = get_bits(mode, 6, 7) * 2 + 6; // 6, 8, 10 or 12
|
||
|
|
block->endpoint_range = get_bits(mode, 8, 12); // 0..20 <= 2^5
|
||
|
|
}
|
||
|
|
|
||
|
|
export void astc_encode_ispc(uniform rgba_surface src[], uniform float block_scores[], uniform uint8_t dst[], uniform uint64_t list[], uniform astc_enc_context list_context[], uniform astc_enc_settings settings[])
|
||
|
|
{
|
||
|
|
uint64_t entry = list[programIndex];
|
||
|
|
uint32_t offset = entry >> 32;
|
||
|
|
uint32_t mode = (entry & 0xFFFFFFFF);
|
||
|
|
if (mode == 0) return;
|
||
|
|
int yy = offset >> 16;
|
||
|
|
int xx = offset & 0xFFFF;
|
||
|
|
|
||
|
|
int tex_width = src->width / settings->block_width;
|
||
|
|
|
||
|
|
astc_enc_state _state;
|
||
|
|
varying astc_enc_state* uniform state = &_state;
|
||
|
|
|
||
|
|
state->block_width = settings->block_width;
|
||
|
|
state->block_height = settings->block_height;
|
||
|
|
state->refineIterations = settings->refineIterations;
|
||
|
|
|
||
|
|
load_block_interleaved(state->pixels, src, xx, yy, state->block_width, state->block_height);
|
||
|
|
|
||
|
|
astc_block _block;
|
||
|
|
varying astc_block* uniform block = &_block;
|
||
|
|
|
||
|
|
load_block_parameters(block, mode, list_context);
|
||
|
|
|
||
|
|
scale_pixels(state, list_context);
|
||
|
|
if (block->channels == 3) clear_alpha(state->scaled_pixels, block->width, block->height);
|
||
|
|
|
||
|
|
if (block->dual_plane)
|
||
|
|
{
|
||
|
|
pixel_set pset;
|
||
|
|
pset.pixels = state->scaled_pixels;
|
||
|
|
pset.width = block->width;
|
||
|
|
pset.height = block->height;
|
||
|
|
|
||
|
|
rotate_plane(&pset, block->color_component_selector);
|
||
|
|
}
|
||
|
|
|
||
|
|
optimize_block(state->scaled_pixels, block, state);
|
||
|
|
float error = measure_error(block, state);
|
||
|
|
|
||
|
|
if (error < gather_float(block_scores, yy * tex_width + xx))
|
||
|
|
{
|
||
|
|
pack_block(block, state);
|
||
|
|
|
||
|
|
scatter_float(block_scores, yy * tex_width + xx, error);
|
||
|
|
|
||
|
|
for (uniform int i = 0; i < 4; i++)
|
||
|
|
scatter_uint((uint32_t*)dst, (yy * tex_width + xx) * 4 + i, state->data[i]);
|
||
|
|
}
|
||
|
|
}
|