dmlib: tools/lib64gfx.c comparison

comparison tools/lib64gfx.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	c6ee41fd98dd
children	c3c1d3c75f53

comparison

equal deleted inserted replaced

-:ef6c826c5b7a
+:9807ae37ad69
 #define BUF_SIZE_INITIAL   (16*1024)
 #define BUF_SIZE_GROW      (4*1024)
-int dmC64PaletteFromC64Colors(DMPalette **ppal, const DMColor *colors, const BOOL mixed)
+int dmC64PaletteFromC64Colors(DMPalette **ppal, const DMColor *colors, const bool mixed)
 {
 int res;
 if (ppal == NULL || colors == NULL)
 return DMERR_NULLPTR;
 return DMERR_OK;
 }
-int dmC64PaletteFromC64Palette(DMPalette **ppal, const DMC64Palette *cpal, const BOOL mixed)
+int dmC64PaletteFromC64Palette(DMPalette **ppal, const DMC64Palette *cpal, const bool mixed)
 {
 if (ppal == NULL || cpal == NULL)
 return DMERR_NULLPTR;
 return dmC64PaletteFromC64Colors(ppal, cpal->colors, mixed);
 }
-int dmC64SetImagePalette(DMImage *img, const DMC64ImageConvSpec *spec, const BOOL mixed)
+int dmC64SetImagePalette(DMImage *img, const DMC64ImageConvSpec *spec, const bool mixed)
 {
 if (img == NULL || spec == NULL)
 return DMERR_NULLPTR;
 // Free previous palette
 if (!img->constpal)
 dmPaletteFree(img->pal);
-img->constpal = FALSE;
+img->constpal = false;
 // If specific palette is wanted, use it
 if (spec->pal != NULL)
 {
 if (spec->pal->ncolors > D64_NCOLORS)
 // Else, use the c64 palette specified
 return dmC64PaletteFromC64Palette(&img->pal, spec->cpal, mixed);
 }
-BOOL dmCompareAddr16(const DMGrowBuf *buf, const size_t offs, const Uint16 addr)
+bool dmCompareAddr16(const DMGrowBuf *buf, const size_t offs, const Uint16 addr)
 {
 return
 offs + 1 < buf->len &&
 buf->data[offs    ] == (addr & 0xff) &&
 buf->data[offs + 1] == ((addr >> 8) & 0xff);
 }
 int dmC64ConvertCSDataToImage(DMImage *img,
 const int xoffs, const int yoffs, const Uint8 *buf,
-const int width, const int height, const BOOL multicolor,
+const int width, const int height, const bool multicolor,
 const int *colors)
 {
 int yc, widthpx = width * 8;
 Uint8 *dpp;
 void dmSetupRLEBuffers(DMGrowBuf *dst, DMGrowBuf *src, const DMCompParams *cfg)
 {
 if (src != NULL && (cfg->flags & DM_RLE_BACKWARDS_INPUT))
 {
 src->offs = src->len;
-src->backwards = TRUE;
+src->backwards = true;
 }
 if (dst != NULL && (cfg->flags & DM_RLE_BACKWARDS_OUTPUT))
 {
-dst->backwards = TRUE;
+dst->backwards = true;
 dst->offs = dst->size;
 }
 #ifdef RLE_DEBUG
 fprintf(stderr, "dmSetupRLEBuffers:\n");
 }
 int dmEncodeGenericRLESequence(DMGrowBuf *dst, const Uint8 data, unsigned int count, const DMCompParams *cfg)
 {
-BOOL copyOnly = FALSE;
+bool copyOnly = false;
 int res;
 switch (cfg->type)
 {
 case DM_COMP_RLE_MARKER:
 goto out;
 break;
 }
 }
 else
-copyOnly = TRUE;
+copyOnly = true;
 break;
 case DM_COMP_RLE_MASK:
 if (count >= cfg->rleMinCountB || (data & cfg->rleMarkerMask) == cfg->rleMarkerBits)
 {
 if (!dmGrowBufPutU8(dst, cfg->rleMarkerBits | count) ||
 !dmGrowBufPutU8(dst, data))
 goto out;
 }
 else
-copyOnly = TRUE;
+copyOnly = true;
 break;
 }
 if (copyOnly && (res = dmGenericRLEOutputRun(dst, cfg, data, count)) != DMERR_OK)
 return res;
 return DMERR_OK;
 }
-int dmC64EncodeGenericBMP(const BOOL allocate, DMGrowBuf *buf, const DMC64Image *img, const DMC64ImageFormat *fmt)
+int dmC64EncodeGenericBMP(const bool allocate, DMGrowBuf *buf, const DMC64Image *img, const DMC64ImageFormat *fmt)
 {
 DMC64EncDecCtx ctx;
 int res = DMERR_OK;
 if (img == NULL || fmt == NULL)
 int dmC64ConvertBMP2Image(DMImage **pdst, const DMC64Image *src, const DMC64ImageConvSpec *pspec)
 {
 DMC64ImageConvSpec spec;
-BOOL mixed;
+bool mixed;
 int res;
 if (pdst == NULL || src == NULL || pspec == NULL)
 return DMERR_NULLPTR;
 if ((size_t) probeOffs >= buf->len)
 return DMERR_OUT_OF_DATA;
 dmGrowBufConstCopyOffs(&tmp, buf, probeOffs);
-if (dmC64ProbeBMP(&tmp, fmt) == DM_PROBE_SCORE_FALSE)
+if (dmC64ProbeBMP(&tmp, fmt) == DM_PROBE_SCORE_false)
 return DMERR_NOT_SUPPORTED;
 }
 if (*fmt == NULL)
 return DMERR_NOT_SUPPORTED;
 // Attempt to encode the image to a buffer
 if (fmt->encode != NULL)
 res = fmt->encode(buf, img, fmt);
 else
-res = dmC64EncodeGenericBMP(FALSE, buf, img, fmt);
+res = dmC64EncodeGenericBMP(false, buf, img, fmt);
 if (res != DMERR_OK)
 goto out;
 // Finally, if the format has a set size and our buffer is smaller
 // if it contains a supported "C64" image format. Returns the
 // "probe score", see libgfx.h for list of values. If a match
 // is found, pointer to format description is set to *pfmt.
 int dmC64ProbeBMP(const DMGrowBuf *buf, const DMC64ImageFormat **pfmt)
 {
-int scoreMax = DM_PROBE_SCORE_FALSE, scoreIndex = -1;
+int scoreMax = DM_PROBE_SCORE_false, scoreIndex = -1;
 for (int i = 0; i < ndmC64ImageFormats; i++)
 {
 const DMC64ImageFormat *fmt = &dmC64ImageFormats[i];
-int score = DM_PROBE_SCORE_FALSE;
+int score = DM_PROBE_SCORE_false;
 if (fmt->probe == NULL && fmt->size > 0 && fmt->addr > 0)
 {
 // Generic probe just checks matching size and load address
 if (buf->len == fmt->size && dmCompareAddr16(buf, 0, fmt->addr))
 score = DM_PROBE_SCORE_GOOD;
 {
 *pfmt = &dmC64ImageFormats[scoreIndex];
 return scoreMax;
 }
 else
-return DM_PROBE_SCORE_FALSE;
+return DM_PROBE_SCORE_false;
 }
-BOOL             dmLib64GFXInitialized = FALSE;
+bool             dmLib64GFXInitialized = false;
 DMC64ImageFormat **dmC64ImageFormatsSorted = NULL;
 int dmC64ImageFormatCompare(const void *va, const void *vb)
 {
 {
 // Safety check
 if (dmLib64GFXInitialized)
 dmLib64GFXClose();
-dmLib64GFXInitialized = TRUE;
+dmLib64GFXInitialized = true;
 if ((dmC64ImageFormatsSorted = dmCalloc(ndmC64ImageFormats, sizeof(dmC64ImageFormatsSorted[0]))) == NULL)
 return DMERR_MALLOC;
 for (int i = 0; i < ndmC64ImageFormats; i++)
 void dmLib64GFXClose(void)
 {
 dmFreeR(&dmC64ImageFormatsSorted);
-dmLib64GFXInitialized = FALSE;
+dmLib64GFXInitialized = false;
 }

Mercurial > hg > dmlib

comparison tools/lib64gfx.c @ 2586:9807ae37ad69