{

const int width = 256;

const int height = 256;

const int max_iter = 1000;

// Create a more interesting color palette

uint8_t palette[256][3];

for (int i = 0; i < 256; i++)

{

if (i < 64)

{

// Blue to cyan transition

palette[i][0] = static_cast<uint8_t>(0); // Red component

palette[i][1] = static_cast<uint8_t>(i * 4); // Green component

palette[i][2] = static_cast<uint8_t>(255); // Blue component

}

else if (i < 128)

{

// Cyan to green transition

palette[i][0] = static_cast<uint8_t>(0); // Red component

palette[i][1] = static_cast<uint8_t>(255); // Green component

palette[i][2] = static_cast<uint8_t>(255 - (i - 64) * 4); // Blue component

}

else if (i < 192)

{

// Green to yellow transition

palette[i][0] = static_cast<uint8_t>((i - 128) * 4); // Red component

palette[i][1] = static_cast<uint8_t>(255); // Green component

palette[i][2] = static_cast<uint8_t>(0); // Blue component

}

else

{

// Yellow to red transition

palette[i][0] = static_cast<uint8_t>(255); // Red component

palette[i][1] = static_cast<uint8_t>(255 - (i - 192) * 4); // Green component

palette[i][2] = static_cast<uint8_t>(0); // Blue component

}

}

// Iterate over each pixel in the image

for (int px = 0; px < width; px++)

{

for (int py = 0; py < height; py++)

{

double x0 = (px - width / 2.0) * 4.0 / width;

double y0 = (py - height / 2.0) * 4.0 / height;

double zx = 0.0;

double zy = 0.0;

double zx_squared = 0.0;

double zy_squared = 0.0;

double x_temp;

int iter;

for (iter = 0; iter < max_iter; iter++)

{

zx_squared = zx * zx;

zy_squared = zy * zy;

if (zx_squared + zy_squared > 4.0) break;

// Update z = z^2 + c, but split into real and imaginary parts

x_temp = zx_squared - zy_squared + x0;

zy = 2.0 * zx * zy + y0;

zx = x_temp;

}

// Map the number of iterations to a color in the palette

int color_idx = iter % 256;

// Set the pixel color in the image

img.set_clipped(px, py, vec4F(((float)palette[color_idx][0])/128.0f, ((float)palette[color_idx][1])/128.0f, ((float)palette[color_idx][2])/128.0f));

}

}

{

const uint32_t W = 512, H = 512;

image img(W, H);

for (uint32_t y = 0; y < H; y++)

for (uint32_t x = 0; x < W; x++)

img(x, y).set(0, y >> 1, x >> 1, ((x ^ y) & 1) ? 255 : 0);

basisu::vector<image> source_images;

source_images.push_back(img);

size_t file_size = 0;

uint32_t quality_level = 255;

// basis_compress() is a simple wrapper around the basis_compressor_params and basis_compressor classes.

void* pKTX2_data = basis_compress(

source_images,

quality_level | cFlagSRGB | cFlagGenMipsClamp | cFlagThreaded | cFlagPrintStats | cFlagDebug | cFlagPrintStatus | cFlagUseOpenCL, 0.0f,

&file_size,

nullptr);

if (!pKTX2_data)

return false;

if (!write_data_to_file("test_etc1s.ktx2", pKTX2_data, file_size))

{

basis_free_data(pKTX2_data);

return false;

}

basis_free_data(pKTX2_data);

return true;

{

const uint32_t W = 512, H = 512;

image img(W, H);

for (uint32_t y = 0; y < H; y++)

for (uint32_t x = 0; x < W; x++)

img(x, y).set(x >> 1, y >> 1, 0, 1);

basisu::vector<image> source_images;

source_images.push_back(img);

size_t file_size = 0;

// basis_compress() is a simple wrapper around the basis_compressor_params and basis_compressor classes.

void* pKTX2_data = basis_compress(

source_images,

cFlagThreaded | cFlagUASTC | cFlagPrintStats | cFlagDebug | cFlagPrintStatus, 0.0f,

&file_size,

nullptr);

if (!pKTX2_data)

return false;

if (!write_data_to_file("test_uastc_ldr.ktx2", pKTX2_data, file_size))

{

basis_free_data(pKTX2_data);

return false;

}

basis_free_data(pKTX2_data);

return true;

{

const uint32_t W = 256, H = 256;

imagef img(W, H);

#if 1

create_mandelbrot(img);

#else

for (uint32_t y = 0; y < H; y++)

for (uint32_t x = 0; x < W; x++)

img(x, y).set(((x ^ y) & 1) ? basist::ASTC_HDR_MAX_VAL : 1000.0f);

#endif

basis_compressor_params params;

params.m_hdr = true;

params.m_source_images_hdr.push_back(img);

params.m_uastc_hdr_options.set_quality_level(3);

params.m_debug = true;

//params.m_debug_images = true;

params.m_status_output = true;

params.m_compute_stats = true;

params.m_create_ktx2_file = true;

params.m_write_output_basis_or_ktx2_files = true;

params.m_out_filename = "test_uastc_hdr.ktx2";

params.m_perceptual = true;

#if 1

// Create a job pool containing 7 total threads (the calling thread plus 6 additional threads).

// A job pool must be created, even if threading is disabled. It's fine to pass in 0 for NUM_THREADS.

const uint32_t NUM_THREADS = 6;

job_pool jp(NUM_THREADS);

params.m_pJob_pool = &jp;

params.m_multithreading = true;

#else

// No threading

const uint32_t NUM_THREADS = 1;

job_pool jp(NUM_THREADS);

params.m_pJob_pool = &jp;

params.m_multithreading = false;

#endif

basis_compressor comp;

if (!comp.init(params))

return false;

basisu::basis_compressor::error_code ec = comp.process();

if (ec != basisu::basis_compressor::cECSuccess)

return false;

return true;

{

// Note: The encoder already initializes the transcoder, but if you haven't initialized the encoder you MUST call this function to initialize the transcoder.

basist::basisu_transcoder_init();

// Read the .KTX2 file's data into memory.

uint8_vec ktx2_file_data;

if (!read_file_to_vec("test_uastc_hdr.ktx2", ktx2_file_data))

return false;

// Create the KTX2 transcoder object.

basist::ktx2_transcoder transcoder;

// Initialize the transcoder.

if (!transcoder.init(ktx2_file_data.data(), ktx2_file_data.size()))

return false;

const uint32_t width = transcoder.get_width();

const uint32_t height = transcoder.get_height();

printf("Texture dimensions: %ux%u, levels: %u\n", width, height, transcoder.get_levels());

// This example only transcodes UASTC HDR textures.

if (!transcoder.is_hdr())

return false;

// Begin transcoding (this will be a no-op with UASTC HDR textures, but you still need to do it. For ETC1S it'll unpack the global codebooks.)

transcoder.start_transcoding();

// Transcode to BC6H and write a BC6H .DDS file.

{

gpu_image tex(texture_format::cBC6HUnsigned, width, height);

bool status = transcoder.transcode_image_level(0, 0, 0,

tex.get_ptr(), tex.get_total_blocks(),

basist::transcoder_texture_format::cTFBC6H, 0);

if (!status)

return false;

gpu_image_vec tex_vec;

tex_vec.push_back(tex);

if (!write_compressed_texture_file("test_uastc_hdr_bc6h.dds", tex_vec, true))

return false;

}

// Transcode to ASTC HDR 4x4 and write a ASTC 4x4 HDR .astc file.

{

gpu_image tex(texture_format::cASTC_HDR_4x4, width, height);

bool status = transcoder.transcode_image_level(0, 0, 0,

tex.get_ptr(), tex.get_total_blocks(),

basist::transcoder_texture_format::cTFASTC_HDR_4x4_RGBA, 0);

if (!status)

return false;

if (!write_astc_file("test_uastc_hdr_astc.astc", tex.get_ptr(), 4, 4, tex.get_pixel_width(), tex.get_pixel_height()))

return false;

}

// Transcode to RGBA HALF and write an .EXR file.

{

basisu::vector<uint16_t> half_img(width * 4 * height);

bool status = transcoder.transcode_image_level(0, 0, 0,

half_img.get_ptr(), half_img.size() / 4,

basist::transcoder_texture_format::cTFRGBA_HALF, 0);

if (!status)

return false;

// Convert FP16 (half float) image to 32-bit float

imagef float_img(transcoder.get_width(), transcoder.get_height());

for (uint32_t y = 0; y < transcoder.get_height(); y++)

{

for (uint32_t x = 0; x < transcoder.get_height(); x++)

{

float_img(x, y).set(

basist::half_to_float(half_img[(x + y * width) * 4 + 0]),

basist::half_to_float(half_img[(x + y * width) * 4 + 1]),

basist::half_to_float(half_img[(x + y * width) * 4 + 2]),

1.0f);

}

}

if (!write_exr("test_uastc_hdr_rgba_half.exr", float_img, 3, 0))

return false;

}

return true;

{

printf("block_unpack_and_transcode_example:\n");

for (uint32_t test_block_iter = 0; test_block_iter < NUM_TEST_BLOCKS; test_block_iter++)

{

printf("-- Test block %u:\n", test_block_iter);

const uint8_t* pASTC_blk = &g_test_blocks[test_block_iter * 2 + 0][0];

const uint8_t* pBC6H_blk = &g_test_blocks[test_block_iter * 2 + 1][0];

// Unpack the physical ASTC block to logical.

// Note this is a full ASTC block unpack, and is not specific to UASTC. It does not verify that the block follows the UASTC HDR spec, only ASTC.

astc_helpers::log_astc_block log_blk;

bool status = astc_helpers::unpack_block(pASTC_blk, log_blk, 4, 4);

assert(status);

if (!status)

{

fprintf(stderr, "Could not unpack ASTC HDR block!\n");

return false;

}

// Print out basic block configuration.

printf("Solid color: %u\n", log_blk.m_solid_color_flag_hdr);

if (!log_blk.m_solid_color_flag_hdr)

{

printf("Num partitions: %u\n", log_blk.m_num_partitions);

printf("CEMs: %u %u\n", log_blk.m_color_endpoint_modes[0], log_blk.m_color_endpoint_modes[1]);

printf("Weight ISE range: %u\n", log_blk.m_weight_ise_range);

printf("Endpoint ISE range: %u\n", log_blk.m_endpoint_ise_range);

}

// Try to transcode this block to BC6H. This will fail if the block is not UASTC HDR.

basist::bc6h_block transcoded_bc6h_blk;

status = basist::astc_hdr_transcode_to_bc6h(*(const basist::astc_blk*)pASTC_blk, transcoded_bc6h_blk);

if (!status)

printf("!");

assert(status);

// Make sure our transcoded BC6H block matches the unexpected block from the UASTC HDR spec.

if (memcmp(&transcoded_bc6h_blk, pBC6H_blk, 16) == 0)

{

printf("Block transcoded OK\n");

}

else

{

fprintf(stderr, "Block did NOT transcode as expected\n");

return false;

}

} // test_block_iter

printf("Transcode test OK\n");

return true;

{

printf("fuzz_uastc_hdr_transcoder_test:\n");

basisu::rand rg;

rg.seed(2000);

#ifdef __SANITIZE_ADDRESS__

const uint32_t NUM_TRIES = 100000000;

#else

const uint32_t NUM_TRIES = 2000000;

#endif

for (uint32_t t = 0; t < NUM_TRIES; t++)

{

basist::astc_blk astc_blk;

if (rg.frand(0.0f, 1.0f) < .3f)

{

// Fully random block

for (uint32_t k = 0; k < 16; k++)

((uint8_t*)&astc_blk)[k] = rg.byte();

}

else

{

// Take a UASTC HDR block and corrupt it

uint32_t test_block_index = rg.irand(0, NUM_TEST_BLOCKS - 1);

const uint8_t* pGood_ASTC_blk = &g_test_blocks[test_block_index * 2 + 0][0];

memcpy(&astc_blk, pGood_ASTC_blk, 16);

const uint32_t num_regions = rg.irand(1, 3);

for (uint32_t k = 0; k < num_regions; k++)

{

if (rg.bit())

{

// Flip a set of random bits

const uint32_t bit_index = rg.irand(0, 127);

const uint32_t num_bits = rg.irand(1, 128 - 127);

assert((bit_index + num_bits) <= 128);

for (uint32_t i = 0; i < num_bits; i++)

{

uint32_t bit_ofs = bit_index + i;

assert(bit_ofs < 128);

uint32_t bit_mask = 1 << (bit_ofs & 7);

uint32_t byte_ofs = bit_ofs >> 3;

assert(byte_ofs < 16);

((uint8_t*)&astc_blk)[byte_ofs] ^= bit_mask;

}

}

else

{

// Set some bits to random values

const uint32_t bit_index = rg.irand(0, 127);

const uint32_t num_bits = rg.irand(1, 128 - 127);

assert((bit_index + num_bits) <= 128);

for (uint32_t i = 0; i < num_bits; i++)

{

uint32_t bit_ofs = bit_index + i;

assert(bit_ofs < 128);

uint32_t bit_mask = 1 << (bit_ofs & 7);

uint32_t byte_ofs = bit_ofs >> 3;

assert(byte_ofs < 16);

((uint8_t*)&astc_blk)[byte_ofs] &= ~bit_mask;

if (rg.bit())

((uint8_t*)&astc_blk)[byte_ofs] |= bit_mask;

}

}

} // k

}

basist::bc6h_block bc6h_blk;

bool status = basist::astc_hdr_transcode_to_bc6h(astc_blk, bc6h_blk);

if (!(t % 100000))

printf("%u %u\n", t, status);

}

printf("OK\n");

{

BASISU_NOTE_UNUSED(arg_c);

BASISU_NOTE_UNUSED(arg_v);

#if USE_ENCODER

basisu_encoder_init(USE_OPENCL, false);

if (!block_unpack_and_transcode_example())

return EXIT_FAILURE;

fuzz_uastc_hdr_transcoder_test();

if (!encode_etc1s())

{

fprintf(stderr, "encode_etc1s() failed!\n");

return EXIT_FAILURE;

}

if (!encode_uastc_hdr())

{

fprintf(stderr, "encode_uastc_hdr() failed!\n");

return EXIT_FAILURE;

}

if (!encode_uastc_ldr())

{

fprintf(stderr, "encode_uastc_ldr() failed!\n");

return EXIT_FAILURE;

}

#endif

if (!transcode_hdr())

{

fprintf(stderr, "transcode_hdr() failed!\n");

return EXIT_FAILURE;

}

printf("All functions succeeded\n");

return EXIT_SUCCESS;