fully customizable options

Author: Aikku93

Qualetize.c

@@ -33,12 +33,13 @@ struct BGRAf_t Qualetize(
 	struct TilesData_t *TilesData,
 	uint8_t *PxData,
 	struct BGRAf_t *Palette,
-	int MaxTilePals,
-	int MaxPalSize,
-	int PalUnused,
+	int   MaxTilePals,
+	int   MaxPalSize,
+	int   PalUnused,
 	const struct BGRA8_t *BitRange,
-	int DitherType,
-	int ReplaceImage
+	int   DitherType,
+	float DitherLevel,
+	int   ReplaceImage
 ) {
 	int i;
 
@@ -91,6 +92,7 @@ struct BGRAf_t Qualetize(
 			//! NOTE: For some reason, it works better to use the square root as a weight.
 			//! This probably gives a value somewhere between the arithmetic mean and
 			//! the smooth-max, which should result in better quality.
+			//! NOTE: Pre-multiply by DitherLevel to remove a multiply from the main loop.
 			struct BGRAf_t Spread = {0,0,0,0}, SpreadW = {0,0,0,0};
 			for(n=PalUnused;n<MaxPalSize;n++) {
 				struct BGRAf_t d = BGRAf_Sub(&Palette[i*MaxPalSize+n], &Mean);
@@ -100,10 +102,11 @@ struct BGRAf_t Qualetize(
 				Spread  = BGRAf_Add(&Spread,  &d);
 				SpreadW = BGRAf_Add(&SpreadW, &w);
 			}
-			PaletteSpread[i] = BGRAf_DivSafe(&Spread, &SpreadW, NULL);
+			Spread = BGRAf_DivSafe(&Spread, &SpreadW, NULL);
 #ifdef DITHER_NO_ALPHA
-			PaletteSpread[i].a = 0.0f;
+			Spread.a = 0.0f;
 #endif
+			PaletteSpread[i] = BGRAf_Muli(&Spread, DitherLevel);
 		}
 	}
 
@@ -129,7 +132,7 @@ struct BGRAf_t Qualetize(
 #ifdef DITHER_NO_ALPHA
 				Dif.a = 0.0f;
 #endif
-				Dif = BGRAf_Muli(&Dif, DITHER_LEVEL);
+				Dif = BGRAf_Muli(&Dif, DitherLevel);
 				Px  = BGRAf_Add (&Px, &Dif);
 			} else {
 				//! Adjust for dither matrix
@@ -139,7 +142,7 @@ struct BGRAf_t Qualetize(
 					Threshold = Threshold*2 + (xKey & 1), xKey >>= 1;
 				} while(--Bit >= 0);
 				float fThres = Threshold * (1.0f / (1 << (2*DitherType))) - 0.5f;
-				struct BGRAf_t DitherVal = BGRAf_Muli(&PaletteSpread[PalIdx], fThres*DITHER_LEVEL);
+				struct BGRAf_t DitherVal = BGRAf_Muli(&PaletteSpread[PalIdx], fThres);
 				Px = BGRAf_Add(&Px, &DitherVal);
 			}
 		}
@@ -172,6 +175,8 @@ struct BGRAf_t Qualetize(
 		}
 #if MEASURE_PSNR
 		//! Accumulate squared error
+		//! NOTE: Accumulate in BGRA, as this is more meaningful.
+		Error = BGRAf_FromYCoCg(&Error);
 		Error = BGRAf_Mul(&Error, &Error);
 		RMSE  = BGRAf_Add(&RMSE, &Error);
 #endif

Qualetize.h

@@ -7,15 +7,12 @@
 /**************************************/
 
 //! Dither modes available
-#define DITHER_NONE           ( 0) //! No dither
-#define DITHER_ORDERED(n)     ( n) //! Ordered dithering (Kernel size: (2^n) x (2^n))
-#define DITHER_FLOYDSTEINBERG (-1) //! Floyd-Steinberg (diffusion)
-
-//! Dither settings
 //! NOTE: Ordered dithering gives consistent tiled results, but Floyd-Steinberg can look nicer.
 //!       Recommend dither level of 0.5 for ordered, and 1.0 for Floyd-Steinberg.
 //! NOTE: DITHER_NO_ALPHA disables dithering on the alpha channel.
-#define DITHER_LEVEL 0.5f
+#define DITHER_NONE           ( 0) //! No dither
+#define DITHER_ORDERED(n)     ( n) //! Ordered dithering (Kernel size: (2^n) x (2^n))
+#define DITHER_FLOYDSTEINBERG (-1) //! Floyd-Steinberg (diffusion)
 #define DITHER_NO_ALPHA
 
 /**************************************/
@@ -29,12 +26,13 @@ struct BGRAf_t Qualetize(
 	struct TilesData_t *TilesData,
 	uint8_t *PxData,
 	struct BGRAf_t *Palette,
-	int MaxTilePals,
-	int MaxPalSize,
-	int PalUnused,
+	int   MaxTilePals,
+	int   MaxPalSize,
+	int   PalUnused,
 	const struct BGRA8_t *BitRange,
-	int DitherType,
-	int ReplaceImage
+	int   DitherType,
+	float DitherLevel,
+	int   ReplaceImage
 );
 
 /**************************************/

tilequant.c

@@ -2,56 +2,139 @@
 #include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 /**************************************/
 #include "Bitmap.h"
 #include "Colourspace.h"
 #include "Qualetize.h"
 #include "Tiles.h"
 /**************************************/
-#define TILE_W 8
-#define TILE_H 8
-#define PALUNUSED 1 //! These will be filled with {0,0,0,0} but still be used for matching
-#define BITRANGE (const struct BGRA8_t){0x1F,0x1F,0x1F,0x01} //! None of these may be 0
 
-//! Default dither mode
-#define DITHER_TYPE DITHER_ORDERED(3)
+//! When not zero, the PSNR for each channel will be displayed
+#define MEASURE_PSNR 1
 
 /**************************************/
 
-//! When not zero, the PSNR for each channel will be displayed
-#define MEASURE_PSNR 1
+//! strcmp() implementation that ACTUALLY returns the difference between
+//! characters instead of just the signs. Blame the C standard -_-
+static int mystrcmp(const char *s1, const char *s2) {
+	while(*s1 && *s1 == *s2) s1++, s2++;
+	return *s1 - *s2;
+}
 
 /**************************************/
 
 int main(int argc, const char *argv[]) {
 	//! Check arguments
-	if(argc != 5) {
+	if(argc < 3) {
 		printf(
 			"tilequant - Tiled colour-quantization tool\n"
-			"Usage: tilequant Input.bmp Output.bmp (no. of palettes) (entries/palette)\n"
+			"Usage:\n"
+			" tilequant Input.bmp Output.bmp [options]\n"
+			"Options:\n"
+			" -np:16            - Set number of palettes available\n"
+			" -ps:16            - Set number of colours per palette\n"
+			" -tw:8             - Set tile width\n"
+			" -th:8             - Set tile height\n"
+			" -bgra:5551        - Set BGRA bit depth\n"
+			" -dither:floyd,1.0 - Set dither mode, level\n"
+			"Dither modes available (and default level):\n"
+			" -dither:none       - No dithering\n"
+			" -dither:floyd,1.0  - Floyd-Steinberg\n"
+			" -dither:ord2,0.5   - 2x2 ordered dithering\n"
+			" -dither:ord4,0.5   - 4x4 ordered dithering\n"
+			" -dither:ord8,0.5   - 8x8 ordered dithering\n"
+			" -dither:ord16,0.5  - 16x16 ordered dithering\n"
+			" -dither:ord32,0.5  - 32x32 ordered dithering\n"
+			" -dither:ord64,0.5  - 64x64 ordered dithering\n"
 		);
 		return 1;
 	}
 
 	//! Parse arguments
-	int MaxTilePals = atoi(argv[3]);
-	int MaxPalSize  = atoi(argv[4]);
+	int     nPalettes = 16;
+	int     nColoursPerPalette = 16;
+	int     nUnusedColoursPerPalette = 1;
+	int     TileW = 8;
+	int     TileH = 8;
+	uint8_t BitRange[4] = {0x1F,0x1F,0x1F,0x01};
+	int     DitherMode  = DITHER_FLOYDSTEINBERG;
+	float   DitherLevel = 1.0f; {
+		int argi;
+		for(argi=3;argi<argc;argi++) {
+			int ArgOk = 0;
+
+			const char *ArgStr;
+#define ARGMATCH(Input, Target) \
+	ArgStr = Input + strlen(Target); \
+	if(!memcmp(Input, Target, strlen(Target)))
+			//! nPalettes
+			ARGMATCH(argv[argi], "-np:") ArgOk = 1, nPalettes = atoi(ArgStr);
+
+			//! nColoursPerPalette
+			ARGMATCH(argv[argi], "-ps:") ArgOk = 1, nColoursPerPalette = atoi(ArgStr);
+
+			//! nUnusedColoursPerPalette
+
+			//! TileW
+			ARGMATCH(argv[argi], "-tw:") ArgOk = 1, TileW = atoi(ArgStr);
+
+			//! TileH
+			ARGMATCH(argv[argi], "-th:") ArgOk = 1, TileH = atoi(ArgStr);
+
+			//! BitRange
+			ARGMATCH(argv[argi], "-bgra:") {
+				ArgOk = 1;
+				BitRange[0] = (1 << (*ArgStr++ - '0')) - 1;
+				BitRange[1] = (1 << (*ArgStr++ - '0')) - 1;
+				BitRange[2] = (1 << (*ArgStr++ - '0')) - 1;
+				BitRange[3] = (1 << (*ArgStr++ - '0')) - 1;
+			}
+
+			//! DitherMode,DitherLevel
+			ARGMATCH(argv[argi], "-dither:") {
+				int d;
+#define DITHERMODE_MATCH(Input, Target, ModeValue, DefaultLevel) \
+	d = mystrcmp(Input, Target); \
+	if(!d || d == ',') { \
+		ArgOk = 1; \
+		DitherMode  = ModeValue; \
+		DitherLevel = !d ? DefaultLevel : atof(strchr(Input, ',')+1); \
+	}
+				DITHERMODE_MATCH(ArgStr, "none",  DITHER_NONE,           0.0f);
+				DITHERMODE_MATCH(ArgStr, "floyd", DITHER_FLOYDSTEINBERG, 1.0f);
+				DITHERMODE_MATCH(ArgStr, "ord2",  DITHER_ORDERED(1),     0.5f);
+				DITHERMODE_MATCH(ArgStr, "ord4",  DITHER_ORDERED(2),     0.5f);
+				DITHERMODE_MATCH(ArgStr, "ord8",  DITHER_ORDERED(3),     0.5f);
+				DITHERMODE_MATCH(ArgStr, "ord16", DITHER_ORDERED(4),     0.5f);
+				DITHERMODE_MATCH(ArgStr, "ord32", DITHER_ORDERED(5),     0.5f);
+				DITHERMODE_MATCH(ArgStr, "ord64", DITHER_ORDERED(6),     0.5f);
+#undef DITHERMODE_MATCH
+				if(!ArgOk) printf("Unrecognized dither mode: %s\n", ArgStr);
+				ArgOk = 1;
+			}
+#undef ARGMATCH
+
+			//! Unrecognized?
+			if(!ArgOk) printf("Unrecognized argument: %s\n", ArgStr);
+		}
+	}
 
 	//! Get input image
 	struct BmpCtx_t Image;
 	if(!BmpCtx_FromFile(&Image, argv[1])) {
 		printf("Unable to read input file\n");
 		return -1;
 	}
-	if(Image.Width%TILE_W || Image.Height%TILE_H) {
-		printf("Image not a multiple of tile size (%dx%d)\n", TILE_W, TILE_H);
+	if(Image.Width%TileW || Image.Height%TileH) {
+		printf("Image not a multiple of tile size (%dx%d)\n", TileW, TileH);
 		BmpCtx_Destroy(&Image);
 		return -1;
 	}
 
 	//! Perform processing
 	//! NOTE: PxData and Palette will be assigned to image; do NOT destroy
-	struct TilesData_t *TilesData = TilesData_FromBitmap(&Image, TILE_W, TILE_H);
+	struct TilesData_t *TilesData = TilesData_FromBitmap(&Image, TileW, TileH);
 	       uint8_t     *PxData    = malloc(Image.Width * Image.Height * sizeof(uint8_t));
 	struct BGRAf_t     *Palette   = calloc(BMP_PALETTE_COLOURS, sizeof(struct BGRAf_t));
 	if(!TilesData || !PxData || !Palette) {
@@ -63,7 +146,7 @@ int main(int argc, const char *argv[]) {
 		return -1;
 	}
 	struct BGRAf_t RMSE = Qualetize(
-		&Image, TilesData, PxData, Palette, MaxTilePals, MaxPalSize, PALUNUSED, &BITRANGE, DITHER_TYPE, 1
+		&Image, TilesData, PxData, Palette, nPalettes, nColoursPerPalette, nUnusedColoursPerPalette, BitRange, DitherMode, DitherLevel, 1
 	);
 	free(TilesData);
 

tilequantDLL.c

@@ -16,12 +16,13 @@
 //!   SrcPxData = uint8_t[Width*Height]
 //!   SrcPxPal  = (struct BGRA8_t)[]
 //!  General:
-//!   DstPxIdx   = uint8_t[Width*Height]
-//!   DstPal     = (struct BGRA8_t)[nPalettes * nColoursPerPalette]
+//!   DstPxIdx    = uint8_t[Width*Height]
+//!   DstPal      = (struct BGRA8_t)[nPalettes * nColoursPerPalette]
 //!    NOTE: DstPal must have enough space to accomodate:
 //!     (struct BGRAf_t)[nPalettes * nColoursPerPalette]
-//!   TilePalIdx = NULL or int32_t[(Width*Height) / (TileW*TileH)]
-//!   DitherMode = Dither mode to use: 0 = DITHER_NONE, -1 = DITHER_FLOYDSTEINBERG, n = DITHER_ORDERED(n)
+//!   TilePalIdx  = NULL or int32_t[(Width*Height) / (TileW*TileH)]
+//!   DitherMode  = Dither mode to use: 0 = DITHER_NONE, -1 = DITHER_FLOYDSTEINBERG, n = DITHER_ORDERED(n)
+//!   DitherLevel = Scale of the dither (0.0 = No dither, 1.0 = Full dither)
 //! OutputPaletteIs24bitRGB outputs RGB (byte order: {RR, GG, BB})
 //! colours without an alpha channel; the default is to output to
 //! BGRA (byte order: {BB, GG, RR, AA}).
@@ -43,7 +44,8 @@ DECLSPEC int QualetizeFromRawImage(
 	int      TileH,
 	int32_t *TilePalIdx,
 	const uint8_t BitRange[4],
-	int           DitherMode
+	int           DitherMode,
+	float         DitherLevel
 ) {
 	//! Create image context
 	//! NOTE: 'const' violations in image data, but not modified so this is safe
@@ -60,7 +62,16 @@ DECLSPEC int QualetizeFromRawImage(
 	struct TilesData_t *TilesData = TilesData_FromBitmap(&Ctx, TileW, TileH);
 	if(!TilesData) return 0;
 	(void)Qualetize(
-		&Ctx, TilesData, DstPxIdx, (struct BGRAf_t*)DstPal, nPalettes, nColoursPerPalette, nUnusedColoursPerPalette, (const struct BGRA8_t*)BitRange, DitherMode, 0
+		&Ctx, TilesData,
+		DstPxIdx,
+		(struct BGRAf_t*)DstPal,
+		nPalettes,
+		nColoursPerPalette,
+		nUnusedColoursPerPalette,
+		(const struct BGRA8_t*)BitRange,
+		DitherMode,
+		DitherLevel
+		0
 	);
 
 	//! Store tile palette indices