Prune decimation_info for decompress-only builds

solidpixel · solidpixel · commit a79a963b82df · 2026-03-25T21:18:48.000Z
diff --git a/Source/astcenc_block_sizes.cpp b/Source/astcenc_block_sizes.cpp
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 // ----------------------------------------------------------------------------
-// Copyright 2011-2025 Arm Limited
+// Copyright 2011-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
@@ -260,7 +260,9 @@ static void init_decimation_info_2d(
 	unsigned int texels_per_block = x_texels * y_texels;
 	unsigned int weights_per_block = x_weights * y_weights;
 
+#if !defined(ASTCENC_DECOMPRESS_ONLY)
 	uint8_t max_texel_count_of_weight = 0;
+#endif
 
 	promise(weights_per_block > 0);
 	promise(texels_per_block > 0);
@@ -316,7 +318,9 @@ static void init_decimation_info_2d(
 					wb.texels_of_weight[qweight[i]][wb.texel_count_of_weight[qweight[i]]] = static_cast<uint8_t>(texel);
 					wb.texel_weights_of_weight[qweight[i]][wb.texel_count_of_weight[qweight[i]]] = static_cast<uint8_t>(weight[i]);
 					wb.texel_count_of_weight[qweight[i]]++;
+#if !defined(ASTCENC_DECOMPRESS_ONLY)
 					max_texel_count_of_weight = astc::max(max_texel_count_of_weight, wb.texel_count_of_weight[qweight[i]]);
+#endif
 				}
 			}
 		}
@@ -331,21 +335,26 @@ static void init_decimation_info_2d(
 		for (unsigned int j = 0; j < wb.weight_count_of_texel[i]; j++)
 		{
 			di.texel_weight_contribs_int_tr[j][i] = wb.weights_of_texel[i][j];
+#if !defined(ASTCENC_DECOMPRESS_ONLY)
 			di.texel_weight_contribs_float_tr[j][i] = static_cast<float>(wb.weights_of_texel[i][j]) * (1.0f / WEIGHTS_TEXEL_SUM);
+#endif
 			di.texel_weights_tr[j][i] = wb.grid_weights_of_texel[i][j];
 		}
 
 		// Init all 4 entries so we can rely on zeros for vectorization
 		for (unsigned int j = wb.weight_count_of_texel[i]; j < 4; j++)
 		{
 			di.texel_weight_contribs_int_tr[j][i] = 0;
+#if !defined(ASTCENC_DECOMPRESS_ONLY)
 			di.texel_weight_contribs_float_tr[j][i] = 0.0f;
+#endif
 			di.texel_weights_tr[j][i] = 0;
 		}
 	}
 
 	di.max_texel_weight_count = max_texel_weight_count;
 
+#if !defined(ASTCENC_DECOMPRESS_ONLY)
 	for (unsigned int i = 0; i < weights_per_block; i++)
 	{
 		unsigned int texel_count_wt = wb.texel_count_of_weight[i];
@@ -382,6 +391,7 @@ static void init_decimation_info_2d(
 			di.weights_texel_contribs_tr[j][i] = 0.0f;
 		}
 	}
+#endif
 
 	// Initialize array tail so we can over-fetch with SIMD later to avoid loop tails
 	size_t texels_per_block_simd = round_up_to_simd_multiple_vla(texels_per_block);
@@ -391,12 +401,15 @@ static void init_decimation_info_2d(
 
 		for (size_t j = 0; j < 4; j++)
 		{
+#if !defined(ASTCENC_DECOMPRESS_ONLY)
 			di.texel_weight_contribs_float_tr[j][i] = 0;
+#endif
 			di.texel_weights_tr[j][i] = 0;
 			di.texel_weight_contribs_int_tr[j][i] = 0;
 		}
 	}
 
+#if !defined(ASTCENC_DECOMPRESS_ONLY)
 	// Initialize array tail so we can over-fetch with SIMD later to avoid loop tails
 	// Match last texel in active lane in SIMD group, for better gathers
 	unsigned int last_texel_count_wt = wb.texel_count_of_weight[weights_per_block - 1];
@@ -413,6 +426,7 @@ static void init_decimation_info_2d(
 			di.weights_texel_contribs_tr[j][i] = 0.0f;
 		}
 	}
+#endif
 
 	di.texel_count = static_cast<uint8_t>(texels_per_block);
 	di.weight_count = static_cast<uint8_t>(weights_per_block);
@@ -446,7 +460,9 @@ static void init_decimation_info_3d(
 	unsigned int texels_per_block = x_texels * y_texels * z_texels;
 	unsigned int weights_per_block = x_weights * y_weights * z_weights;
 
+#if !defined(ASTCENC_DECOMPRESS_ONLY)
 	uint8_t max_texel_count_of_weight = 0;
+#endif
 
 	promise(weights_per_block > 0);
 	promise(texels_per_block > 0);
@@ -571,7 +587,9 @@ static void init_decimation_info_3d(
 						wb.texels_of_weight[qweight[i]][wb.texel_count_of_weight[qweight[i]]] = static_cast<uint8_t>(texel);
 						wb.texel_weights_of_weight[qweight[i]][wb.texel_count_of_weight[qweight[i]]] = static_cast<uint8_t>(weight[i]);
 						wb.texel_count_of_weight[qweight[i]]++;
+#if !defined(ASTCENC_DECOMPRESS_ONLY)
 						max_texel_count_of_weight = astc::max(max_texel_count_of_weight, wb.texel_count_of_weight[qweight[i]]);
+#endif
 					}
 				}
 			}
@@ -588,20 +606,25 @@ static void init_decimation_info_3d(
 		for (unsigned int j = 0; j < 4; j++)
 		{
 			di.texel_weight_contribs_int_tr[j][i] = 0;
+#if !defined(ASTCENC_DECOMPRESS_ONLY)
 			di.texel_weight_contribs_float_tr[j][i] = 0.0f;
+#endif
 			di.texel_weights_tr[j][i] = 0;
 		}
 
 		for (unsigned int j = 0; j < wb.weight_count_of_texel[i]; j++)
 		{
 			di.texel_weight_contribs_int_tr[j][i] = wb.weights_of_texel[i][j];
+#if !defined(ASTCENC_DECOMPRESS_ONLY)
 			di.texel_weight_contribs_float_tr[j][i] = static_cast<float>(wb.weights_of_texel[i][j]) * (1.0f / WEIGHTS_TEXEL_SUM);
+#endif
 			di.texel_weights_tr[j][i] = wb.grid_weights_of_texel[i][j];
 		}
 	}
 
 	di.max_texel_weight_count = max_texel_weight_count;
 
+#if !defined(ASTCENC_DECOMPRESS_ONLY)
 	for (unsigned int i = 0; i < weights_per_block; i++)
 	{
 		unsigned int texel_count_wt = wb.texel_count_of_weight[i];
@@ -638,6 +661,7 @@ static void init_decimation_info_3d(
 			di.weights_texel_contribs_tr[j][i] = 0.0f;
 		}
 	}
+#endif
 
 	// Initialize array tail so we can over-fetch with SIMD later to avoid loop tails
 	size_t texels_per_block_simd = round_up_to_simd_multiple_vla(texels_per_block);
@@ -647,12 +671,15 @@ static void init_decimation_info_3d(
 
 		for (size_t j = 0; j < 4; j++)
 		{
+#if !defined(ASTCENC_DECOMPRESS_ONLY)
 			di.texel_weight_contribs_float_tr[j][i] = 0;
+#endif
 			di.texel_weights_tr[j][i] = 0;
 			di.texel_weight_contribs_int_tr[j][i] = 0;
 		}
 	}
 
+#if !defined(ASTCENC_DECOMPRESS_ONLY)
 	// Initialize array tail so we can over-fetch with SIMD later to avoid loop tails
 	// Match last texel in active lane in SIMD group, for better gathers
 	int last_texel_count_wt = wb.texel_count_of_weight[weights_per_block - 1];
@@ -669,6 +696,7 @@ static void init_decimation_info_3d(
 			di.weights_texel_contribs_tr[j][i] = 0.0f;
 		}
 	}
+#endif
 
 	di.texel_count = static_cast<uint8_t>(texels_per_block);
 	di.weight_count = static_cast<uint8_t>(weights_per_block);
diff --git a/Source/astcenc_internal.h b/Source/astcenc_internal.h
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 // ----------------------------------------------------------------------------
-// Copyright 2011-2024 Arm Limited
+// Copyright 2011-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
@@ -381,6 +381,7 @@ struct decimation_info
 	 */
 	ASTCENC_ALIGNAS uint8_t texel_weight_contribs_int_tr[4][BLOCK_MAX_TEXELS];
 
+#if !defined(ASTCENC_DECOMPRESS_ONLY)
 	/**
 	 * @brief The bilinear contribution of the N weights that are interpolated for each texel.
 	 * Value is between 0 and 1, stored transposed to improve vectorization.
@@ -407,6 +408,7 @@ struct decimation_info
 	 * Value is between 0 and 1, stored transposed to improve vectorization.
 	 */
 	float texel_contrib_for_weight[BLOCK_MAX_TEXELS][BLOCK_MAX_WEIGHTS];
+#endif
 };
 
 /**

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`// SPDX-License-Identifier: Apache-2.0`
`2`	`2`	`// ----------------------------------------------------------------------------`
`3`		`-// Copyright 2011-2025 Arm Limited`
	`3`	`+// Copyright 2011-2026 Arm Limited`
`4`	`4`	`//`
`5`	`5`	`// Licensed under the Apache License, Version 2.0 (the "License"); you may not`
`6`	`6`	`// use this file except in compliance with the License. You may obtain a copy`
`@@ -260,7 +260,9 @@ static void init_decimation_info_2d(`
`260`	`260`	`unsigned int texels_per_block = x_texels * y_texels;`
`261`	`261`	`unsigned int weights_per_block = x_weights * y_weights;`
`262`	`262`
	`263`	`+#if !defined(ASTCENC_DECOMPRESS_ONLY)`
`263`	`264`	`uint8_t max_texel_count_of_weight = 0;`
	`265`	`+#endif`
`264`	`266`
`265`	`267`	`promise(weights_per_block > 0);`
`266`	`268`	`promise(texels_per_block > 0);`
`@@ -316,7 +318,9 @@ static void init_decimation_info_2d(`
`316`	`318`	`wb.texels_of_weight[qweight[i]][wb.texel_count_of_weight[qweight[i]]] = static_cast<uint8_t>(texel);`
`317`	`319`	`wb.texel_weights_of_weight[qweight[i]][wb.texel_count_of_weight[qweight[i]]] = static_cast<uint8_t>(weight[i]);`
`318`	`320`	`wb.texel_count_of_weight[qweight[i]]++;`
	`321`	`+#if !defined(ASTCENC_DECOMPRESS_ONLY)`
`319`	`322`	`max_texel_count_of_weight = astc::max(max_texel_count_of_weight, wb.texel_count_of_weight[qweight[i]]);`
	`323`	`+#endif`
`320`	`324`	`}`
`321`	`325`	`}`
`322`	`326`	`}`
`@@ -331,21 +335,26 @@ static void init_decimation_info_2d(`
`331`	`335`	`for (unsigned int j = 0; j < wb.weight_count_of_texel[i]; j++)`
`332`	`336`	`{`
`333`	`337`	`di.texel_weight_contribs_int_tr[j][i] = wb.weights_of_texel[i][j];`
	`338`	`+#if !defined(ASTCENC_DECOMPRESS_ONLY)`
`334`	`339`	`di.texel_weight_contribs_float_tr[j][i] = static_cast<float>(wb.weights_of_texel[i][j]) * (1.0f / WEIGHTS_TEXEL_SUM);`
	`340`	`+#endif`
`335`	`341`	`di.texel_weights_tr[j][i] = wb.grid_weights_of_texel[i][j];`
`336`	`342`	`}`
`337`	`343`
`338`	`344`	`// Init all 4 entries so we can rely on zeros for vectorization`
`339`	`345`	`for (unsigned int j = wb.weight_count_of_texel[i]; j < 4; j++)`
`340`	`346`	`{`
`341`	`347`	`di.texel_weight_contribs_int_tr[j][i] = 0;`
	`348`	`+#if !defined(ASTCENC_DECOMPRESS_ONLY)`
`342`	`349`	`di.texel_weight_contribs_float_tr[j][i] = 0.0f;`
	`350`	`+#endif`
`343`	`351`	`di.texel_weights_tr[j][i] = 0;`
`344`	`352`	`}`
`345`	`353`	`}`
`346`	`354`
`347`	`355`	`di.max_texel_weight_count = max_texel_weight_count;`
`348`	`356`
	`357`	`+#if !defined(ASTCENC_DECOMPRESS_ONLY)`
`349`	`358`	`for (unsigned int i = 0; i < weights_per_block; i++)`
`350`	`359`	`{`
`351`	`360`	`unsigned int texel_count_wt = wb.texel_count_of_weight[i];`
`@@ -382,6 +391,7 @@ static void init_decimation_info_2d(`
`382`	`391`	`di.weights_texel_contribs_tr[j][i] = 0.0f;`
`383`	`392`	`}`
`384`	`393`	`}`
	`394`	`+#endif`
`385`	`395`
`386`	`396`	`// Initialize array tail so we can over-fetch with SIMD later to avoid loop tails`
`387`	`397`	`size_t texels_per_block_simd = round_up_to_simd_multiple_vla(texels_per_block);`
`@@ -391,12 +401,15 @@ static void init_decimation_info_2d(`
`391`	`401`
`392`	`402`	`for (size_t j = 0; j < 4; j++)`
`393`	`403`	`{`
	`404`	`+#if !defined(ASTCENC_DECOMPRESS_ONLY)`
`394`	`405`	`di.texel_weight_contribs_float_tr[j][i] = 0;`
	`406`	`+#endif`
`395`	`407`	`di.texel_weights_tr[j][i] = 0;`
`396`	`408`	`di.texel_weight_contribs_int_tr[j][i] = 0;`
`397`	`409`	`}`
`398`	`410`	`}`
`399`	`411`
	`412`	`+#if !defined(ASTCENC_DECOMPRESS_ONLY)`
`400`	`413`	`// Initialize array tail so we can over-fetch with SIMD later to avoid loop tails`
`401`	`414`	`// Match last texel in active lane in SIMD group, for better gathers`
`402`	`415`	`unsigned int last_texel_count_wt = wb.texel_count_of_weight[weights_per_block - 1];`
`@@ -413,6 +426,7 @@ static void init_decimation_info_2d(`
`413`	`426`	`di.weights_texel_contribs_tr[j][i] = 0.0f;`
`414`	`427`	`}`
`415`	`428`	`}`
	`429`	`+#endif`
`416`	`430`
`417`	`431`	`di.texel_count = static_cast<uint8_t>(texels_per_block);`
`418`	`432`	`di.weight_count = static_cast<uint8_t>(weights_per_block);`
`@@ -446,7 +460,9 @@ static void init_decimation_info_3d(`
`446`	`460`	`unsigned int texels_per_block = x_texels * y_texels * z_texels;`
`447`	`461`	`unsigned int weights_per_block = x_weights * y_weights * z_weights;`
`448`	`462`
	`463`	`+#if !defined(ASTCENC_DECOMPRESS_ONLY)`
`449`	`464`	`uint8_t max_texel_count_of_weight = 0;`
	`465`	`+#endif`
`450`	`466`
`451`	`467`	`promise(weights_per_block > 0);`
`452`	`468`	`promise(texels_per_block > 0);`
`@@ -571,7 +587,9 @@ static void init_decimation_info_3d(`
`571`	`587`	`wb.texels_of_weight[qweight[i]][wb.texel_count_of_weight[qweight[i]]] = static_cast<uint8_t>(texel);`
`572`	`588`	`wb.texel_weights_of_weight[qweight[i]][wb.texel_count_of_weight[qweight[i]]] = static_cast<uint8_t>(weight[i]);`
`573`	`589`	`wb.texel_count_of_weight[qweight[i]]++;`
	`590`	`+#if !defined(ASTCENC_DECOMPRESS_ONLY)`
`574`	`591`	`max_texel_count_of_weight = astc::max(max_texel_count_of_weight, wb.texel_count_of_weight[qweight[i]]);`
	`592`	`+#endif`
`575`	`593`	`}`
`576`	`594`	`}`
`577`	`595`	`}`
`@@ -588,20 +606,25 @@ static void init_decimation_info_3d(`
`588`	`606`	`for (unsigned int j = 0; j < 4; j++)`
`589`	`607`	`{`
`590`	`608`	`di.texel_weight_contribs_int_tr[j][i] = 0;`
	`609`	`+#if !defined(ASTCENC_DECOMPRESS_ONLY)`
`591`	`610`	`di.texel_weight_contribs_float_tr[j][i] = 0.0f;`
	`611`	`+#endif`
`592`	`612`	`di.texel_weights_tr[j][i] = 0;`
`593`	`613`	`}`
`594`	`614`
`595`	`615`	`for (unsigned int j = 0; j < wb.weight_count_of_texel[i]; j++)`
`596`	`616`	`{`
`597`	`617`	`di.texel_weight_contribs_int_tr[j][i] = wb.weights_of_texel[i][j];`
	`618`	`+#if !defined(ASTCENC_DECOMPRESS_ONLY)`
`598`	`619`	`di.texel_weight_contribs_float_tr[j][i] = static_cast<float>(wb.weights_of_texel[i][j]) * (1.0f / WEIGHTS_TEXEL_SUM);`
	`620`	`+#endif`
`599`	`621`	`di.texel_weights_tr[j][i] = wb.grid_weights_of_texel[i][j];`
`600`	`622`	`}`
`601`	`623`	`}`
`602`	`624`
`603`	`625`	`di.max_texel_weight_count = max_texel_weight_count;`
`604`	`626`
	`627`	`+#if !defined(ASTCENC_DECOMPRESS_ONLY)`
`605`	`628`	`for (unsigned int i = 0; i < weights_per_block; i++)`
`606`	`629`	`{`
`607`	`630`	`unsigned int texel_count_wt = wb.texel_count_of_weight[i];`
`@@ -638,6 +661,7 @@ static void init_decimation_info_3d(`
`638`	`661`	`di.weights_texel_contribs_tr[j][i] = 0.0f;`
`639`	`662`	`}`
`640`	`663`	`}`
	`664`	`+#endif`
`641`	`665`
`642`	`666`	`// Initialize array tail so we can over-fetch with SIMD later to avoid loop tails`
`643`	`667`	`size_t texels_per_block_simd = round_up_to_simd_multiple_vla(texels_per_block);`
`@@ -647,12 +671,15 @@ static void init_decimation_info_3d(`
`647`	`671`
`648`	`672`	`for (size_t j = 0; j < 4; j++)`
`649`	`673`	`{`
	`674`	`+#if !defined(ASTCENC_DECOMPRESS_ONLY)`
`650`	`675`	`di.texel_weight_contribs_float_tr[j][i] = 0;`
	`676`	`+#endif`
`651`	`677`	`di.texel_weights_tr[j][i] = 0;`
`652`	`678`	`di.texel_weight_contribs_int_tr[j][i] = 0;`
`653`	`679`	`}`
`654`	`680`	`}`
`655`	`681`
	`682`	`+#if !defined(ASTCENC_DECOMPRESS_ONLY)`
`656`	`683`	`// Initialize array tail so we can over-fetch with SIMD later to avoid loop tails`
`657`	`684`	`// Match last texel in active lane in SIMD group, for better gathers`
`658`	`685`	`int last_texel_count_wt = wb.texel_count_of_weight[weights_per_block - 1];`
`@@ -669,6 +696,7 @@ static void init_decimation_info_3d(`
`669`	`696`	`di.weights_texel_contribs_tr[j][i] = 0.0f;`
`670`	`697`	`}`
`671`	`698`	`}`
	`699`	`+#endif`
`672`	`700`
`673`	`701`	`di.texel_count = static_cast<uint8_t>(texels_per_block);`
`674`	`702`	`di.weight_count = static_cast<uint8_t>(weights_per_block);`