dmlib: tools/gfxconv.c comparison

comparison tools/gfxconv.c @ 2586:9807ae37ad69

Require stdbool.h, we require C11 now.

author	Matti Hamalainen <ccr@tnsp.org>
date	Thu, 08 Dec 2022 15:59:22 +0200
parents	bb44c48cffac
children	d683f47e4dd9

comparison

equal deleted inserted replaced

-:ef6c826c5b7a
+:9807ae37ad69
 static int nconvFormatList = 0;
 typedef struct
 {
-BOOL triplet, alpha;
+bool triplet, alpha;
 DMColor color;
 unsigned int from, to;
 } DMMapValue;
 optPlanedWidth = 1,
 optForcedInSubFormat = -1,
 optShowHelp = 0;
 unsigned int optInSkip = 0;
-BOOL    optInSkipNeg = FALSE;
+bool    optInSkipNeg = false;
 int     optCropMode = CROP_NONE,
 optCropX0, optCropY0,
 optCropW, optCropH;
-BOOL    optInMulticolor = FALSE,
+bool    optInMulticolor = false,
-optSequential = FALSE,
+optSequential = false,
-optRemapRemove = FALSE,
+optRemapRemove = false,
-optRemapMatchAlpha = FALSE,
+optRemapMatchAlpha = false,
-optUsePalette = FALSE;
+optUsePalette = false;
 int     optRemapMode = REMAP_NONE;
 int     optNRemapTable = 0,
 optScaleMode = SCALE_AUTO;
 float   optRemapMaxDist = -1;
 int     optRemapNoMatchColor = -1;
 {
 .scaleX = 1,
 .scaleY = 1,
 .nplanes = 0,
 .bpp = 8,
-.planar = FALSE,
+.planar = false,
 .pixfmt = 0,
 .compression = FCMP_BEST,
 };
 DMC64ImageConvSpec optC64Spec;
 default: return "0";
 }
 }
-BOOL dmGetConvFormat(const int type, const int format, DMConvFormat *pfmt)
+bool dmGetConvFormat(const int type, const int format, DMConvFormat *pfmt)
 {
 for (int i = 0; i < nconvFormatList; i++)
 {
 const DMConvFormat *fmt = &convFormatList[i];
 if (fmt->type == type &&
 fmt->format == format)
 {
 memcpy(pfmt, fmt, sizeof(DMConvFormat));
-return TRUE;
+return true;
 }
 }
 for (int i = 0; i < nconvFormatList; i++)
 {
 {
 const DMConvFormat *fmt = &convFormatList[i];
 const DMC64ImageFormat *cfmt = &dmC64ImageFormats[format];
 memcpy(pfmt, fmt, sizeof(DMConvFormat));
 pfmt->fext = cfmt->name;
-return TRUE;
+return true;
 }
 }
-return FALSE;
+return false;
 }
-BOOL dmGetC64FormatByExt(const char *fext, int *type, int *format)
+bool dmGetC64FormatByExt(const char *fext, int *type, int *format)
 {
 if (fext == NULL)
-return FALSE;
+return false;
 for (int i = 0; i < ndmC64ImageFormats; i++)
 {
 const DMC64ImageFormat *fmt = &dmC64ImageFormats[i];
 if (fmt->fext != NULL &&
 strcasecmp(fext, fmt->fext) == 0)
 {
 *type   = FFMT_BITMAP;
 *format = i;
-return TRUE;
+return true;
 }
 }
-return FALSE;
+return false;
 }
-BOOL dmGetFormatByExt(const char *fext, int *type, int *format)
+bool dmGetFormatByExt(const char *fext, int *type, int *format)
 {
 if (fext == NULL)
-return FALSE;
+return false;
 for (int i = 0; i < nconvFormatList; i++)
 {
 const DMConvFormat *fmt = &convFormatList[i];
 if (fmt->fext != NULL &&
 strcasecmp(fext, fmt->fext) == 0)
 {
 *type   = fmt->type;
 *format = fmt->format;
-return TRUE;
+return true;
 }
 }
-return FALSE;
+return false;
 }
-BOOL dmParseMapOptionMapItem(const char *popt, DMMapValue *value, const unsigned int nmax, const char *msg)
+bool dmParseMapOptionMapItem(const char *popt, DMMapValue *value, const unsigned int nmax, const char *msg)
 {
 char *end, *split, *opt = dm_strdup(popt);
 if (opt == NULL)
 goto out;
 unsigned int colR, colG, colB, colA;
 if (sscanf(opt + 1, "%2x%2x%2x%2x", &colR, &colG, &colB, &colA) == 4 ||
 sscanf(opt + 1, "%2X%2X%2X%2X", &colR, &colG, &colB, &colA) == 4)
 {
-value->alpha = TRUE;
+value->alpha = true;
 value->color.a = colA;
 }
 else
 if (sscanf(opt + 1, "%2x%2x%2x", &colR, &colG, &colB) != 3 &&
 sscanf(opt + 1, "%2X%2X%2X", &colR, &colG, &colB) != 3)
 }
 value->color.r = colR;
 value->color.g = colG;
 value->color.b = colB;
-value->triplet = TRUE;
+value->triplet = true;
 }
 else
 {
 if (!dmGetIntVal(opt, &value->from, NULL))
 {
 dmErrorMsg("Invalid %s value '%s', could not parse source value '%s'.\n", msg, popt, opt);
 goto out;
 }
-value->triplet = FALSE;
+value->triplet = false;
 }
 // Trim whitespace
 split++;
 while (*split && isspace(*split)) split++;
 dmErrorMsg("Invalid %s map destination color index value %d, must be [0..%d].\n", msg, value->to, nmax);
 goto out;
 }
 dmFree(opt);
-return TRUE;
+return true;
 out:
 dmFree(opt);
-return FALSE;
+return false;
 }
-BOOL dmParseMapOptionItem(char *opt, char *end, void *pvalue, const int index, const int nmax, const BOOL requireIndex, const char *msg)
+bool dmParseMapOptionItem(char *opt, char *end, void *pvalue, const int index, const int nmax, const bool requireIndex, const char *msg)
 {
 // Trim whitespace
 if (end != NULL)
 {
 *end = 0;
 // Parse item based on mode
 if (requireIndex)
 {
 DMMapValue *value = (DMMapValue *) pvalue;
 if (!dmParseMapOptionMapItem(opt, &value[index], nmax, msg))
-return FALSE;
+return false;
 }
 else
 {
 unsigned int *value = (unsigned int *) pvalue;
 char *split = strchr(opt, ':');
 if (split != NULL)
 {
 dmErrorMsg("Unexpected ':' in indexed %s '%s'.\n", msg, opt);
-return FALSE;
+return false;
 }
 if (!dmGetIntVal(opt, &value[index], NULL))
 {
 dmErrorMsg("Invalid %s value '%s', could not parse.\n", msg, opt);
-return FALSE;
+return false;
 }
 }
-return TRUE;
+return true;
 }
-BOOL dmParseMapOptionString(char *opt, void *values, int *nvalues, const int nmax, const BOOL requireIndex, const char *msg)
+bool dmParseMapOptionString(char *opt, void *values, int *nvalues, const int nmax, const bool requireIndex, const char *msg)
 {
 char *start = opt;
 *nvalues = 0;
 while (*start && *nvalues < nmax)
 {
 char *end = strchr(start, ',');
 if (!dmParseMapOptionItem(start, end, values, *nvalues, nmax, requireIndex, msg))
-return FALSE;
+return false;
 (*nvalues)++;
 if (!end)
 break;
 start = end + 1;
 }
-return TRUE;
+return true;
 }
 int dmParseColorRemapFile(const char *filename, DMMapValue *values, int *nvalue, const int nmax)
 {
 fclose(fp);
 return res;
 }
-BOOL dmParseFormatOption(const char *msg1, const char *msg2, char *optArg, int *format, int *subFormat)
+bool dmParseFormatOption(const char *msg1, const char *msg2, char *optArg, int *format, int *subFormat)
 {
 char *flags = strchr(optArg, ':');
 if (flags != NULL)
 *flags++ = 0;
 if (!dmGetFormatByExt(optArg, format, subFormat) &&
 !dmGetC64FormatByExt(optArg, format, subFormat))
 {
 dmErrorMsg("Invalid %s format '%s', see -F / --formats for format list.\n",
 msg1, optArg);
-return FALSE;
+return false;
 }
 if (flags != NULL)
 {
 switch (*format)
 {
 case FFMT_SPRITE:
 case FFMT_CHAR:
 if (strcasecmp(flags, "mc") == 0)
-optInMulticolor = TRUE;
+optInMulticolor = true;
 else
 if (strcasecmp(flags, "sc") == 0)
-optInMulticolor = FALSE;
+optInMulticolor = false;
 else
 {
 dmErrorMsg("Invalid %s format flags for sprite/char '%s', should be 'mc' or 'sc'.\n",
 msg1, flags);
-return FALSE;
+return false;
 }
 break;
 default:
 dmErrorMsg("%s format '%s' does not support any flags ('%s').\n",
 msg2, optArg, flags);
-return FALSE;
+return false;
 }
 }
-return TRUE;
+return true;
 }
-char *dmParseValWithSep(char **arg, char *last, BOOL (*isok)(const int ch), const char *sep)
+char *dmParseValWithSep(char **arg, char *last, bool (*isok)(const int ch), const char *sep)
 {
 char *ptr = *arg, *end, *start;
 // Skip any whitespace at start
 while (*ptr != 0 && isspace(*ptr))
 return start;
 }
-BOOL dmParseIntValTok(const int ch)
+bool dmParseIntValTok(const int ch)
 {
 return isxdigit(ch) || ch == 'x' || ch == '$';
 }
-BOOL dmParseIntValWithSep(char **arg, unsigned int *value, char *last, const char *sep)
+bool dmParseIntValWithSep(char **arg, unsigned int *value, char *last, const char *sep)
 {
 return dmGetIntVal(dmParseValWithSep(arg, last, dmParseIntValTok, sep), value, NULL);
 }
-BOOL argHandleOpt(const int optN, char *optArg, char *currArg)
+bool argHandleOpt(const int optN, char *optArg, char *currArg)
 {
 unsigned int tmpUInt;
 char *tmpStr;
 switch (optN)
 case 12:
 if (!dmGetIntVal(optArg, &optInSkip, &optInSkipNeg))
 {
 dmErrorMsg("Invalid skip value argument '%s'.\n", optArg);
-return FALSE;
+return false;
 }
 break;
 case 14:
 {
 DMConvFormat fmt;
 if (!dmParseFormatOption("input", "Input", optArg, &optInType, &optForcedInSubFormat))
-return FALSE;
+return false;
 dmGetConvFormat(optInType, optForcedInSubFormat, &fmt);
 if ((fmt.flags & DM_FMT_RD) == 0)
 {
 dmErrorMsg("Invalid input format '%s', does not support reading.\n",
 fmt.name);
-return FALSE;
+return false;
 }
 }
 break;
 case 16:
 {
 DMConvFormat fmt;
 if (!dmParseFormatOption("output", "Output", optArg, &optOutType, &optOutFormat))
-return FALSE;
+return false;
 dmGetConvFormat(optOutType, optOutFormat, &fmt);
 if ((fmt.flags & DM_FMT_WR) == 0)
 {
 dmErrorMsg("Invalid output format '%s', does not support writing.\n",
 fmt.name);
-return FALSE;
+return false;
 }
 }
 break;
 case 18:
 optShowHelp = 3;
 break;
 case 20:
-optSequential = TRUE;
+optSequential = true;
 break;
 case 22:
 if (strcasecmp(optArg, "help") == 0)
 {
 }
 else
 {
 int ncolors;
 if (!dmParseMapOptionString(optArg, optColorMap,
-&ncolors, D64_NCOLORS, FALSE, "color index option"))
+&ncolors, D64_NCOLORS, false, "color index option"))
-return FALSE;
+return false;
 dmMsg(1, "Set color index mapping: ");
 for (int index = 0; index < ncolors; index++)
 {
 dmPrint(1, "[%d:%d]%s",
 if (!dmGetIntVal(optArg, &tmpUInt, NULL) ||
 tmpUInt < 1)
 {
 dmErrorMsg("Invalid count value argument '%s' [1 .. MAXINT]\n",
 optArg);
-return FALSE;
+return false;
 }
 optItemCount = tmpUInt;
 break;
 case 26:
 if (!dmGetIntVal(optArg, &tmpUInt, NULL) ||
 tmpUInt < 1 || tmpUInt > 512)
 {
 dmErrorMsg("Invalid planed width value '%s' [1 .. 512]\n",
 optArg);
-return FALSE;
+return false;
 }
 optPlanedWidth = tmpUInt;
 break;
 case 28:
 fprintf(stdout, "\n%s\n", argGetHelpTopic(optN));
 exit(0);
 }
 else
 {
-BOOL error = FALSE;
+bool error = false;
 unsigned int tmpUInt2;
 char *tmpStr = dm_strdup(optArg),
 *tmpOpt = tmpStr, sep;
 // Check for "relative scale mode specifier
 if (sep == 0)
 {
 optSpec.scaleX = optSpec.scaleY = tmpUInt;
 }
 else
-error = TRUE;
+error = true;
 }
 else
-error = TRUE;
+error = true;
 dmFree(tmpStr);
 if (error)
 {
 dmErrorMsg(
 "Invalid scale option value '%s', should be [*]<n> or or <w>:<h>[*<n>].\n",
 optArg);
-return FALSE;
+return false;
 }
 if (optSpec.scaleX < 1 || optSpec.scaleX > 50)
 {
 dmErrorMsg("Invalid X scale value %d.\n", optSpec.scaleX);
-return FALSE;
+return false;
 }
 if (optSpec.scaleY < 1 || optSpec.scaleY > 50)
 {
 dmErrorMsg("Invalid Y scale value %d.\n", optSpec.scaleY);
-return FALSE;
+return false;
 }
 }
 break;
 case 30:
-optUsePalette = TRUE;
+optUsePalette = true;
 break;
 case 32:
 if (!dmGetIntVal(optArg, &tmpUInt, NULL) ||
 tmpUInt < 1 || tmpUInt > 8)
 {
 dmErrorMsg("Invalid number of bitplanes value '%s' [1 .. 8]\n",
 optArg);
-return FALSE;
+return false;
 }
 optSpec.nplanes = tmpUInt;
 break;
 case 34:
 if (!dmGetIntVal(optArg, &tmpUInt, NULL) ||
 tmpUInt < 1 || tmpUInt > 32)
 {
 dmErrorMsg("Invalid number of bits per plane value '%s' [1 .. 32]\n",
 optArg);
-return FALSE;
+return false;
 }
 optSpec.bpp = tmpUInt;
 break;
 case 36:
-optSpec.planar = TRUE;
+optSpec.planar = true;
 break;
 case 38:
 if (!dmGetIntVal(optArg, &tmpUInt, NULL) ||
 tmpUInt > FCMP_BEST)
 {
 dmErrorMsg("Invalid compression setting '%s' [%d .. %d]\n",
 optArg, FCMP_NONE, FCMP_BEST);
-return FALSE;
+return false;
 }
 optSpec.compression = tmpUInt;
 break;
 case 40:
 }
 else
 {
 unsigned int tx0, ty0, tx1, ty1;
 char sep, modeSep = 0, *tmpTok, *tmpStr;
-BOOL ok;
+bool ok;
 if ((tmpTok = tmpStr = dm_strdup(optArg)) == NULL)
 {
 dmErrorMsg("Could not allocate memory for temporary string.\n");
-return FALSE;
+return false;
 }
 // Check for 'x0:y0-x1:y1' pattern
 ok = dmParseIntValWithSep(&tmpTok, &tx0, &sep, ":") &&
 sep == ':' &&
 }
 }
 else
 {
 dmErrorMsg("Invalid crop mode / argument '%s'.\n", optArg);
-return FALSE;
+return false;
 }
 }
 break;
 case 42:
 // Parse one sub-option
 char sep, *topt = dmParseValWithSep(&tmpStr, &sep, NULL, "+");
 // Check what option we have
 if (strcasecmp(topt, "remove") == 0)
-optRemapRemove = TRUE;
+optRemapRemove = true;
 else
 if (strcasecmp(topt, "alpha") == 0)
-optRemapMatchAlpha = TRUE;
+optRemapMatchAlpha = true;
 else
 if (strncasecmp(topt, "max=", 4) == 0)
 {
 char *start = topt + 4, *end;
 optRemapMaxDist = strtof(start, &end);
 if (end == start)
 {
 dmErrorMsg("Invalid or missing value parameter for -R option flag: '%s'.\n",
 topt);
-return FALSE;
+return false;
 }
 }
 else
 if (strncasecmp(topt, "nomatch=", 8) == 0)
 {
 if (end == start)
 {
 dmErrorMsg("Invalid or missing value parameter for -R option flag: '%s'.\n",
 topt);
-return FALSE;
+return false;
 }
 if (optRemapNoMatchColor < -1 || optRemapNoMatchColor > 255)
 {
 dmErrorMsg("Invalid remap no-match color value %d. Should be [-1 .. 255].\n",
 optRemapNoMatchColor);
-return FALSE;
+return false;
 }
 }
 else
 {
 dmErrorMsg("Unknown -R option flag '%s'.\n", topt);
-return FALSE;
+return false;
 }
 } while (*tmpStr != 0);
 }
 // Check which remap mode is being requested
 if (strcasecmp(optArg, "auto") == 0)
 {
 if (optRemapMode != REMAP_NONE && optRemapMode != REMAP_AUTO)
 {
 dmErrorMsg("Remap mode already set to something else than 'auto'. You can only have one remapping mode.\n");
-return FALSE;
+return false;
 }
 optRemapMode = REMAP_AUTO;
 }
 else
 {
 if (optRemapMode != REMAP_NONE && optRemapMode != REMAP_MAPPED)
 {
 dmErrorMsg("Remap mode already set to something else than 'mapped'. You can only have one remapping mode.\n");
-return FALSE;
+return false;
 }
 if (optArg[0] == '@')
 {
 if (optArg[1] != 0)
 {
 int res;
 if ((res = dmParseColorRemapFile(optArg + 1,
 optRemapTable, &optNRemapTable, DM_MAX_COLORS)) != DMERR_OK)
-return FALSE;
+return false;
 }
 else
 {
 dmErrorMsg("No remap filename given.\n");
-return FALSE;
+return false;
 }
 }
 else
 {
 if (!dmParseMapOptionString(optArg, optRemapTable,
-&optNRemapTable, DM_MAX_COLORS, TRUE, "color remap option"))
+&optNRemapTable, DM_MAX_COLORS, true, "color remap option"))
-return FALSE;
+return false;
 }
 optRemapMode = REMAP_MAPPED;
 }
 case 46:
 return argHandleC64PaletteOption(optArg, &optC64Palette, &optPaletteFile);
 default:
 dmErrorMsg("Unimplemented option argument '%s'.\n", currArg);
-return FALSE;
+return false;
 }
-return TRUE;
+return true;
 }
-BOOL argHandleFile(char *currArg)
+bool argHandleFile(char *currArg)
 {
 if (!optInFilename)
 optInFilename = currArg;
 else
 {
 dmErrorMsg("Source filename already specified, extraneous argument '%s'.\n",
 currArg);
-return FALSE;
+return false;
 }
-return TRUE;
+return true;
 }
-void dmPrintByte(FILE *out, const Uint8 byte, const int format, const BOOL multicolor, const BOOL dir)
+void dmPrintByte(FILE *out, const Uint8 byte, const int format, const bool multicolor, const bool dir)
 {
 if (multicolor)
 {
 for (int i = 0; i < DM_ASC_NBITS; i += 2)
 {
 }
 }
 }
-void dmDumpCharASCII(FILE *outFile, const Uint8 *buf, const size_t offs, const int fmt, const BOOL multicolor)
+void dmDumpCharASCII(FILE *outFile, const Uint8 *buf, const size_t offs, const int fmt, const bool multicolor)
 {
 for (size_t yc = 0; yc < D64_CHR_HEIGHT_UT; yc++)
 {
 fprintf(outFile, "%04" DM_PRIx_SIZE_T " : ", offs + yc);
-dmPrintByte(outFile, buf[yc], fmt, multicolor, FALSE);
+dmPrintByte(outFile, buf[yc], fmt, multicolor, false);
 fprintf(outFile, "\n");
 }
 }
-void dmDumpSpriteASCII(FILE *outFile, const Uint8 *buf, const size_t offs, const int fmt, BOOL multicolor)
+void dmDumpSpriteASCII(FILE *outFile, const Uint8 *buf, const size_t offs, const int fmt, bool multicolor)
 {
 size_t bufOffs, xc, yc;
 for (bufOffs = yc = 0; yc < D64_SPR_HEIGHT_UT; yc++)
 {
 fprintf(outFile, "%04" DM_PRIx_SIZE_T " ", offs + bufOffs);
 for (xc = 0; xc < D64_SPR_WIDTH_UT; xc++)
 {
-dmPrintByte(outFile, buf[bufOffs], fmt, multicolor, FALSE);
+dmPrintByte(outFile, buf[bufOffs], fmt, multicolor, false);
 fprintf(outFile, " ");
 bufOffs++;
 }
 fprintf(outFile, "\n");
 }
 }
 // XXX TODO: we need to evaluate the color vector itself, not just the distance
-float dmGetColorDist(const DMColor *c1, const DMColor *c2, const BOOL alpha)
+float dmGetColorDist(const DMColor *c1, const DMColor *c2, const bool alpha)
 {
 const float
 dr = (c1->r - c2->r) / 255.0,
 dg = (c1->g - c2->g) / 255.0,
 db = (c1->b - c2->b) / 255.0;
 else
 return (dr * dr + dg * dg + db * db) / 3.0;
 }
-int dmScanUsedColors(const DMImage *src, const BOOL warn, BOOL *used, int *nused)
+int dmScanUsedColors(const DMImage *src, const bool warn, bool *used, int *nused)
 {
-BOOL warned = FALSE;
+bool warned = false;
 *nused = 0;
 if (src == NULL || used == NULL || nused == NULL)
 return DMERR_NULLPTR;
 return dmError(DMERR_INVALID_DATA,
 "Source image is not paletted.\n");
 }
 for (int index = 0; index < src->pal->ncolors; index++)
-used[index] = FALSE;
+used[index] = false;
 for (int yc = 0; yc < src->height; yc++)
 {
 const Uint8 *dp = src->data + src->pitch * yc;
 for (int xc = 0; xc < src->width; xc++)
 Uint8 col = dp[xc];
 if (col < src->pal->ncolors)
 {
 if (!used[col])
 {
-used[col] = TRUE;
+used[col] = true;
 (*nused)++;
 }
 }
 else
 if (warn && !warned)
 {
 dmErrorMsg("Image contains color indices that are out of bounds of the palette.\n");
-warned = TRUE;
+warned = true;
 }
 }
 }
 return DMERR_OK;
 int dmRemapImageColors(DMImage **pdst, const DMImage *src,
 const DMPalette *dpal,
 const float maxDist, const int noMatchColor,
-const BOOL alpha, const BOOL removeUnused)
+const bool alpha, const bool removeUnused)
 {
 DMPalette *tpal = NULL;
 const DMPalette *ppal;
-BOOL *used = NULL;
+bool *used = NULL;
 int *mapping = NULL, *mapped = NULL;
 int res = DMERR_OK;
-BOOL fail = FALSE;
+bool fail = false;
 if (pdst == NULL || src == NULL || dpal == NULL)
 return DMERR_NULLPTR;
 if (src->pal == NULL || src->pixfmt != DM_PIXFMT_PALETTE)
 dmPrint(0,
 "No match for source color #%d. Closest: #%d (%02x %02x %02x) [dist=%1.3f > %1.3f]\n",
 sc, closestDC, dcol->r, dcol->g, dcol->b,
 closestDist, maxDist);
-fail = TRUE;
+fail = true;
 }
 else
 {
 closestDC = noMatchColor;
 }
 {
 dmErrorMsg("WARNING! Removing unused colors with 'no-match' color index set may have unintended results.\n");
 }
 // Get the actually used colors
-if ((res = dmScanUsedColors(src, TRUE, used, &nused)) != DMERR_OK)
+if ((res = dmScanUsedColors(src, true, used, &nused)) != DMERR_OK)
 goto out;
 dmMsg(2, "Found %d used color indices.\n", nused);
 // Remove duplicates from the mapped colour indices
 for (int n = 0; n < src->pal->ncolors; n++)
 if (n != index &&
 mapping[index] == mapping[n] &&
 used[n] && used[index])
 {
-used[n] = FALSE;
+used[n] = false;
 }
 }
 if (noMatchColor >= 0)
-used[noMatchColor] = TRUE;
+used[noMatchColor] = true;
 // Re-count number of actually used indices
 nused = 0;
 for (int index = 0; index < src->pal->ncolors; index++)
 if (used[index])
 int dmMapImageColors(DMImage **pdst, const DMImage *src,
 const DMMapValue *mapTable, const int nmapTable,
 const float maxDist, const int noMatchColor,
-const BOOL alpha, const BOOL removeUnused)
+const bool alpha, const bool removeUnused)
 {
 DMPalette *tpal = NULL;
-BOOL *mapped = NULL, *used = NULL;
+bool *mapped = NULL, *used = NULL;
 int *mapping = NULL;
 int nused, res = DMERR_OK;
-BOOL fail = FALSE;
+bool fail = false;
 if (pdst == NULL || src == NULL || mapTable == NULL)
 return DMERR_NULLPTR;
 if (src->pal == NULL || src->pixfmt != DM_PIXFMT_PALETTE)
 }
 for (int index = 0; index < src->pal->ncolors; index++)
 {
 mapping[index] = -1;
-mapped[index] = FALSE;
+mapped[index] = false;
 }
 if ((res = dmPaletteAlloc(&tpal, src->pal->ncolors, -1)) != DMERR_OK)
 {
 dmErrorMsg("Could not allocate memory for remap palette.\n");
 dmMsg(3, "No RGBA match found for map index %d, #%02x%02x%02x%02x. Closest: #%d (#%02x%02x%02x%02x) [dist=%1.3f > %1.3f]\n",
 index, map->color.r, map->color.g, map->color.b, map->color.a,
 closestDC, dcol->r, dcol->g, dcol->b, dcol->a, closestDist, maxDist);
-fail = TRUE;
+fail = true;
 }
 else
 {
 DMColor *dcol = &src->pal->colors[noMatchColor];
 closestDC = noMatchColor;
 map->color.r, map->color.g, map->color.b, map->color.a,
 map->to,
 closestDC, dcol->r, dcol->g, dcol->b, dcol->a, closestDist);
 mapping[closestDC] = map->to;
-mapped[map->to] = TRUE;
+mapped[map->to] = true;
 }
 }
 else
 {
 DMColor *dcol = &src->pal->colors[closestDC];
 map->color.r, map->color.g, map->color.b, map->color.a,
 map->to,
 closestDC, dcol->r, dcol->g, dcol->b, dcol->a, closestDist);
 mapping[closestDC] = map->to;
-mapped[map->to] = TRUE;
+mapped[map->to] = true;
 }
 }
 else
 {
 dmMsg(3, "Map index: %d -> %d\n",
 map->from, map->to);
 mapping[map->from] = map->to;
-mapped[map->to] = TRUE;
+mapped[map->to] = true;
 }
 }
 if (fail)
 {
 // Fill the unmapped colors
 if (removeUnused)
 {
 dmMsg(2, "Scanning for used colors.\n");
-if ((res = dmScanUsedColors(src, TRUE, used, &nused)) != DMERR_OK)
+if ((res = dmScanUsedColors(src, true, used, &nused)) != DMERR_OK)
 goto out;
 dmMsg(2, "Removing unused colors: %d -> %d.\n",
 src->pal->ncolors, nused);
 }
 {
 for (int n = 0; n < src->pal->ncolors; n++)
 if (!mapped[n])
 {
 mapping[index] = n;
-mapped[n] = TRUE;
+mapped[n] = true;
 break;
 }
 }
 // Copy mapped palette entries
 int dmWriteImage(const char *filename, DMImage *pimage,
 DMImageWriteSpec *spec, const DMImageFormat *fmt)
 {
 int res = DMERR_OK;
 DMImage *image = pimage;
-BOOL allocated = FALSE;
+bool allocated = false;
 // Check if writing is even supported
 if (fmt->write == NULL || (fmt->flags & DM_FMT_WR) == 0)
 {
 return dmError(DMERR_NOT_SUPPORTED,
 &image, pimage, optRemapTable, optNRemapTable,
 optRemapMaxDist, optRemapNoMatchColor,
 optRemapMatchAlpha, optRemapRemove)) != DMERR_OK)
 goto out;
-allocated = TRUE;
+allocated = true;
 break;
 case REMAP_AUTO:
 if (optPaletteData == NULL)
 {
 &image, pimage, optPaletteData,
 optRemapMaxDist, optRemapNoMatchColor,
 optRemapMatchAlpha, optRemapRemove)) != DMERR_OK)
 goto out;
-allocated = TRUE;
+allocated = true;
 break;
 }
 }
 else
 if (optRemapMode != REMAP_NONE)
 return res;
 }
-Uint8 dmConvertByte(const Uint8 *sp, const BOOL multicolor)
+Uint8 dmConvertByte(const Uint8 *sp, const bool multicolor)
 {
 Uint8 byte = 0;
 int xc;
 if (multicolor)
 return byte;
 }
-BOOL dmConvertImage2Char(Uint8 *buf, const DMImage *image,
+bool dmConvertImage2Char(Uint8 *buf, const DMImage *image,
-const int xoffs, const int yoffs, const BOOL multicolor)
+const int xoffs, const int yoffs, const bool multicolor)
 {
 int yc;
 if (xoffs < 0 || yoffs < 0 ||
 xoffs + D64_CHR_WIDTH_PX > image->width ||
 yoffs + D64_CHR_HEIGHT_PX > image->height)
-return FALSE;
+return false;
 for (yc = 0; yc < D64_CHR_HEIGHT_UT; yc++)
 {
 const Uint8 *sp = image->data + ((yc + yoffs) * image->pitch) + xoffs;
 buf[yc] = dmConvertByte(sp, multicolor);
 }
-return TRUE;
+return true;
 }
-BOOL dmConvertImage2Sprite(Uint8 *buf, const DMImage *image,
+bool dmConvertImage2Sprite(Uint8 *buf, const DMImage *image,
-const int xoffs, const int yoffs, const BOOL multicolor)
+const int xoffs, const int yoffs, const bool multicolor)
 {
 int yc, xc;
 if (xoffs < 0 || yoffs < 0 ||
 xoffs + D64_SPR_WIDTH_PX > image->width ||
 yoffs + D64_SPR_HEIGHT_PX > image->height)
-return FALSE;
+return false;
 for (yc = 0; yc < D64_SPR_HEIGHT_UT; yc++)
 {
 for (xc = 0; xc < D64_SPR_WIDTH_PX / D64_SPR_WIDTH_UT; xc++)
 {
 const Uint8 *sp = image->data + ((yc + yoffs) * image->pitch) + (xc * 8) + xoffs;
 buf[(yc * D64_SPR_WIDTH_UT) + xc] = dmConvertByte(sp, multicolor);
 }
 }
-return TRUE;
+return true;
 }
-int dmWriteSpritesAndChars(const char *filename, DMImage *image, int outFormat, const BOOL multicolor)
+int dmWriteSpritesAndChars(const char *filename, DMImage *image, int outFormat, const bool multicolor)
 {
 int ret = DMERR_OK;
 int outBlockW, outBlockH, bx, by;
 FILE *outFile = NULL;
 Uint8 *tmpBuf = NULL;
 offs = 0;
 itemCount = 0;
 if (optOutType == FFMT_ANSI || optOutType == FFMT_ASCII)
 {
-BOOL error = FALSE;
+bool error = false;
 FILE *outFile;
 if (optOutFilename == NULL)
 outFile = stdout;
 else
 outIHeight++;
 outImage = dmImageAlloc(outWidthPX * outIWidth, outIHeight * outHeight, DM_PIXFMT_PALETTE, -1);
 }
-if ((err = dmC64SetImagePalette(outImage, &optC64Spec, FALSE)) != DMERR_OK)
+if ((err = dmC64SetImagePalette(outImage, &optC64Spec, false)) != DMERR_OK)
 {
 dmErrorMsg("Could not allocate C64 palette for output image: %d\n", err);
 goto out;
 }
 goto out;
 case 2:
 argShowHelp();
 argShowFormats();
-argShowC64Formats(stdout, TRUE, TRUE);
+argShowC64Formats(stdout, true, true);
 argShowC64PaletteHelp(stdout);
 for (int n = 0; n < optListN; n++)
 {
 const char *str = argGetHelpTopic(optList[n].id);
 }
 goto out;
 case 3:
 argShowFormats();
-argShowC64Formats(stdout, TRUE, dmVerbosity > 0);
+argShowC64Formats(stdout, true, dmVerbosity > 0);
 goto out;
 }
 // Determine input format, if not specified
 if (optInType == FFMT_AUTO && optInFilename != NULL)
 optC64Palette = &dmC64DefaultPalettes[0];
 dmMsg(1, "Using internal palette '%s' (%s).\n",
 optC64Palette->name, optC64Palette->desc);
-if ((res = dmC64PaletteFromC64Palette(&optPaletteData, optC64Palette, FALSE)) != DMERR_OK)
+if ((res = dmC64PaletteFromC64Palette(&optPaletteData, optC64Palette, false)) != DMERR_OK)
 {
 dmErrorMsg("Could not set up palette: %s.\n",
 dmErrorStr(res));
 goto out;
 }
 if (optC64Palette != NULL)
 {
 dmMsg(1, "Using internal palette '%s' (%s).\n",
 optC64Palette->name, optC64Palette->desc);
-if ((res = dmC64PaletteFromC64Palette(&optPaletteData, optC64Palette, FALSE)) != DMERR_OK)
+if ((res = dmC64PaletteFromC64Palette(&optPaletteData, optC64Palette, false)) != DMERR_OK)
 {
 dmErrorMsg("Could not set up palette: %s.\n",
 dmErrorStr(res));
 goto out;
 }

Mercurial > hg > dmlib

comparison tools/gfxconv.c @ 2586:9807ae37ad69