fuzz_astc_compress.cpp

// SPDX-License-Identifier: Apache-2.0
// ----------------------------------------------------------------------------
// Copyright 2026 Arm Limited
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not
// use this file except in compliance with the License. You may obtain a copy
// of the License at:
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations
// under the License.
// ----------------------------------------------------------------------------

#include "astcenc.h"
#include <fuzzer/FuzzedDataProvider.h>
#include <vector>

extern "C" int LLVMFuzzerTestOneInput(
	const uint8_t *data,
	size_t size
) {
	FuzzedDataProvider fdp(data, size);

	// Randomize block size
	static const struct { uint8_t x, y; } block_sizes[] = {
		{4, 4}, {5, 4}, {5, 5}, {6, 5}, {6, 6}, {8, 5}, {8, 6}, {8, 8},
		{10, 5}, {10, 6}, {10, 8}, {10, 10}, {12, 10}, {12, 12}
	};

	int bs_idx = fdp.ConsumeIntegralInRange<int>(0, (sizeof(block_sizes) / sizeof(block_sizes[0])) - 1);
	uint32_t block_x = block_sizes[bs_idx].x;
	uint32_t block_y = block_sizes[bs_idx].y;
	uint32_t block_z = 1;

	// Randomize profile
	astcenc_profile profile = (astcenc_profile)fdp.ConsumeIntegralInRange<int>(0, 3);

	// Randomize quality
	// For compression, high quality is very slow. Let's limit it for fuzzing.
	float quality = fdp.ConsumeFloatingPointInRange<float>(ASTCENC_PRE_FASTEST, ASTCENC_PRE_MEDIUM);

	// Randomize flags
	unsigned int flags = fdp.ConsumeIntegralInRange<unsigned int>(0, ASTCENC_ALL_FLAGS);
	// Don't use decompress-only flag for compression fuzzer
	flags &= ~ASTCENC_FLG_DECOMPRESS_ONLY;

	astcenc_config config;
	astcenc_error status = astcenc_config_init(profile, block_x, block_y, block_z, quality, flags, &config);
	if (status != ASTCENC_SUCCESS)
	{
		return 0;
	}

	astcenc_context* context = nullptr;
	status = astcenc_context_alloc(&config, 1, &context, nullptr);
	if (status != ASTCENC_SUCCESS)
	{
		return 0;
	}

	// Image dimensions - small to keep it fast
	uint32_t dim_x = block_x;
	uint32_t dim_y = block_y;
	uint32_t dim_z = 1;

	astcenc_image image;
	image.dim_x = dim_x;
	image.dim_y = dim_y;
	image.dim_z = dim_z;
	image.data_type = ASTCENC_TYPE_U8;

	size_t input_data_len = dim_x * dim_y * 4;
	if (fdp.remaining_bytes() < input_data_len)
	{
		astcenc_context_free(context);
		return 0;
	}

	std::vector<uint8_t> input_data = fdp.ConsumeBytes<uint8_t>(input_data_len);
	void* slices[] = { input_data.data() };
	image.data = slices;

	astcenc_swizzle swizzle = {
		ASTCENC_SWZ_R, ASTCENC_SWZ_G, ASTCENC_SWZ_B, ASTCENC_SWZ_A
	};

	size_t compressed_data_len = 16; // One block
	std::vector<uint8_t> compressed_data(compressed_data_len);

	status = astcenc_compress_image(context, &image, &swizzle, compressed_data.data(), compressed_data.size(), 0);

	astcenc_context_free(context);

	return 0;
}