dmlib: tools/libgfx.c comparison

comparison tools/libgfx.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	92b93a12c014
children	c3c1d3c75f53

comparison

equal deleted inserted replaced

-:ef6c826c5b7a
+:9807ae37ad69
 {
 if (len == 0x304 &&
 buf[0x300] == 0)
 return DM_PROBE_SCORE_MAX;
-return DM_PROBE_SCORE_FALSE;
+return DM_PROBE_SCORE_false;
 }
 int dmReadACTPalette(DMResource *fp, DMPalette **pdst)
 {
 (void) buf;
 if (len == 0x300)
 return DM_PROBE_SCORE_MAX;
-return DM_PROBE_SCORE_FALSE;
+return DM_PROBE_SCORE_false;
 }
 int dmReadRAWPalette(DMResource *fp, DMPalette **pdst)
 {
 "Conversion of non-indexed image to indexed not supported yet.\n");
 }
 // Force non-planar etc
 memcpy(&tmpSpec, spec, sizeof(DMImageWriteSpec));
-tmpSpec.planar = FALSE;
+tmpSpec.planar = false;
 switch (tmpSpec.pixfmt)
 {
 case DM_PIXFMT_RGB:
 case DM_PIXFMT_RGBA:
 return dmWriteImageData(img, (void *) fp, dmWritePPMRow, &tmpSpec);
 }
 // Read a PPM/PGM/PNM header line, skipping comments
-static BOOL dmReadPPMHeader(DMResource *fp, char *buf, const size_t bufLen)
+static bool dmReadPPMHeader(DMResource *fp, char *buf, const size_t bufLen)
 {
-BOOL end = FALSE, comment = FALSE;
+bool end = false, comment = false;
 size_t offs = 0;
 do
 {
 int ch = dmfgetc(fp);
 if (ch == EOF)
-return FALSE;
+return false;
 else
 if (ch == '#')
-comment = TRUE;
+comment = true;
 else
 if (ch == '\n')
 {
 if (!comment)
-end = TRUE;
+end = true;
 else
-comment = FALSE;
+comment = false;
 }
 else
 if (!comment)
 {
 if (offs < bufLen - 1)
 buf[offs++] = ch;
 }
 } while (!end);
 buf[offs] = 0;
-return TRUE;
+return true;
 }
 int dmReadPPMImage(DMResource *fp, DMImage **pimg)
 {
 if (len > 32 &&
 buf[0] == 'P' &&
 (buf[1] == '5' || buf[1] == '6'))
 return DM_PROBE_SCORE_MAX;
-return DM_PROBE_SCORE_FALSE;
+return DM_PROBE_SCORE_false;
 }
 #ifdef DM_USE_LIBPNG
 static int fmtProbePNG(const Uint8 *buf, const size_t len)
 return DM_PROBE_SCORE_MAX;
 else
 return DM_PROBE_SCORE_GOOD;
 }
-return DM_PROBE_SCORE_FALSE;
+return DM_PROBE_SCORE_false;
 }
 static int dmWritePNGRow(void *cbdata, const Uint8 *row, const size_t len)
 {
 buf[2] == 1 &&
 (buf[3] == 8 || buf[3] == 4 || buf[3] == 3 || buf[3] == 1) &&
 buf[65] >= 1 && buf[65] <= 4)
 return DM_PROBE_SCORE_GOOD;
-return DM_PROBE_SCORE_FALSE;
+return DM_PROBE_SCORE_false;
 }
 // Returns one byte from row buffer (of length len) at offset soffs,
 // OR zero if the offset is outside buffer.
 static inline Uint8 dmPCXGetByte(const Uint8 *row, const size_t len, const size_t soffs)
 {
 return (soffs < len) ? row[soffs] : 0;
 }
-static BOOL dmPCXFlush(DMPCXData *pcx)
+static bool dmPCXFlush(DMPCXData *pcx)
 {
-BOOL ret = TRUE;
+bool ret = true;
 if (pcx->bufOffs > 0)
 ret = dmf_write_str(pcx->fp, pcx->buf, pcx->bufOffs);
 pcx->bufOffs = 0;
 return ret;
 }
-static inline BOOL dmPCXPutByte(DMPCXData *pcx, const Uint8 val)
+static inline bool dmPCXPutByte(DMPCXData *pcx, const Uint8 val)
 {
 if (pcx->bufOffs < pcx->bufLen)
 {
 pcx->buf[pcx->bufOffs++] = val;
-return TRUE;
+return true;
 }
 else
 return dmPCXFlush(pcx);
 }
 DMImageWriteSpec spec;
 int res;
 // Always force planar for PCX
 memcpy(&spec, pspec, sizeof(DMImageWriteSpec));
-spec.planar = TRUE;
+spec.planar = true;
 // XXX: 24bit PCX does not work yet ..
 if ((img->pixfmt != DM_PIXFMT_PALETTE && img->pixfmt != DM_PIXFMT_GRAYSCALE) ||
 (spec.pixfmt != DM_PIXFMT_PALETTE && spec.pixfmt != DM_PIXFMT_GRAYSCALE))
 {
 dmFree(pcx.buf);
 return res;
 }
-static BOOL dmPCXDecodeRLERow(DMResource *fp, Uint8 *buf, const size_t bufLen)
+static bool dmPCXDecodeRLERow(DMResource *fp, Uint8 *buf, const size_t bufLen)
 {
 size_t offs = 0;
 do
 {
 int count;
 Uint8 data;
 if (!dmf_read_byte(fp, &data))
-return FALSE;
+return false;
 if ((data & 0xC0) == 0xC0)
 {
-BOOL skip = FALSE;
+bool skip = false;
 count = data & 0x3F;
 if (count == 0)
 {
 switch (dmGFXErrorMode)
 {
 case DM_ERRMODE_RECOV_1:
 // Use as literal
-skip = TRUE;
+skip = true;
 count = 1;
 break;
 case DM_ERRMODE_RECOV_2:
 // Ignore completely
-skip = TRUE;
+skip = true;
 break;
 case DM_ERRMODE_FAIL:
 default:
 // Error out on "invalid" data
-return FALSE;
+return false;
 }
 }
 if (!skip && !dmf_read_byte(fp, &data))
-return FALSE;
+return false;
 }
 else
 count = 1;
 while (count-- && offs < bufLen)
 buf[offs++] = data;
 // Check for remaining output count, error out if we wish to
 if (count > 0 && dmGFXErrorMode == DM_ERRMODE_FAIL)
-return FALSE;
+return false;
 } while (offs < bufLen);
-return TRUE;
+return true;
 }
 int dmReadPCXImage(DMResource *fp, DMImage **pimg)
 {
 DMImage *img;
 DMPCXData pcx;
 DMPCXHeader hdr;
 int res = 0;
-BOOL isPaletted;
+bool isPaletted;
 pcx.buf = NULL;
 // Read PCX header
 if (!dmf_read_byte(fp, &hdr.manufacturer) ||
 !dmf_read_byte(fp, &hdr.version) ||
 // Read additional VGA palette, if available
 if (isPaletted)
 {
 int ncolors;
 Uint8 tmpb;
-BOOL read;
+bool read;
 if (!dmf_read_byte(fp, &tmpb) || tmpb != 0x0C)
 {
-read = FALSE;
+read = false;
 ncolors = PCX_PAL_COLORS;
 }
 else
 {
-read = TRUE;
+read = true;
 ncolors = 256;
 }
 if ((res = dmPaletteAlloc(&(img->pal), ncolors, -1)) != DMERR_OK)
 {
 return DM_PROBE_SCORE_MAX;
 else
 return DM_PROBE_SCORE_GOOD;
 }
-return DM_PROBE_SCORE_FALSE;
+return DM_PROBE_SCORE_false;
 }
 static int fmtProbeIFF_ILBM(const Uint8 *buf, const size_t len)
 {
 return DMERR_OK;
 }
 static int dmCheckIFFChunk(DMIFFChunk *dest, const DMIFFChunk *chunk,
-const BOOL multi, const Uint32 minSize)
+const bool multi, const Uint32 minSize)
 {
 if (dest->count > 0 && !multi)
 {
 return dmError(DMERR_INVALID_DATA,
 "IFF: Multiple instances of chunk %s found.\n",
 return DMERR_OK;
 }
-BOOL dmIFFDecodeByteRun1Row(DMResource *fp, Uint8 *buf, const size_t bufLen)
+bool dmIFFDecodeByteRun1Row(DMResource *fp, Uint8 *buf, const size_t bufLen)
 {
 size_t offs = 0;
 do
 {
 Uint8 data, ucount;
 if (!dmf_read_byte(fp, &ucount))
-return FALSE;
+return false;
 if (ucount == 0x80)
 {
 if (!dmf_read_byte(fp, &data))
-return FALSE;
+return false;
 }
 else
 if (ucount & 0x80)
 {
 Uint8 count = (ucount ^ 0xff) + 2;
 if (!dmf_read_byte(fp, &data))
-return FALSE;
+return false;
 while (count-- && offs < bufLen)
 buf[offs++] = data;
 }
 else
 {
 Uint8 count = ucount + 1;
 while (count-- && offs < bufLen)
 {
 if (!dmf_read_byte(fp, &data))
-return FALSE;
+return false;
 buf[offs++] = data;
 }
 }
 } while (offs < bufLen);
-return TRUE;
+return true;
 }
-static BOOL dmIFFReadOneRow(DMResource *fp, DMIFF *iff, Uint8 *buf, const size_t bufLen)
+static bool dmIFFReadOneRow(DMResource *fp, DMIFF *iff, Uint8 *buf, const size_t bufLen)
 {
 if (iff->bmhd.compression == IFF_COMP_BYTERUN1)
 return dmIFFDecodeByteRun1Row(fp, buf, bufLen);
 else
 return dmf_read_str(fp, buf, bufLen);
 int dmReadIFFImage(DMResource *fp, DMImage **pimg)
 {
 DMIFFChunk chunk;
 DMIFF iff;
-BOOL parsed = FALSE;
+bool parsed = false;
 int res = DMERR_OK;
 memset(&iff, 0, sizeof(iff));
 // Read IFF FORM header
 switch (chunk.id)
 {
 case IFF_ID_BMHD:
 // Check for multiple occurences of BMHD
-if ((res = dmCheckIFFChunk(&iff.chBMHD, &chunk, FALSE, sizeof(iff.bmhd))) != DMERR_OK)
+if ((res = dmCheckIFFChunk(&iff.chBMHD, &chunk, false, sizeof(iff.bmhd))) != DMERR_OK)
 return res;
 // Read BMHD data
 if (!dmf_read_be16(fp, &iff.bmhd.w) ||
 !dmf_read_be16(fp, &iff.bmhd.h) ||
 break;
 case IFF_ID_CMAP:
 // Check for multiple occurences of CMAP
-if ((res = dmCheckIFFChunk(&iff.chCMAP, &chunk, FALSE, 3)) != DMERR_OK)
+if ((res = dmCheckIFFChunk(&iff.chCMAP, &chunk, false, 3)) != DMERR_OK)
 return res;
 // Check for sanity
 if (chunk.size % 3 != 0)
 {
 return res;
 }
 }
 if (iff.chBMHD.count && iff.chBODY.count)
-parsed = TRUE;
+parsed = true;
 break;
 case IFF_ID_BODY:
 case IFF_ID_ABIT:
 // Check for multiple occurences of BODY
-if ((res = dmCheckIFFChunk(&iff.chBODY, &chunk, FALSE, 1)) != DMERR_OK)
+if ((res = dmCheckIFFChunk(&iff.chBODY, &chunk, false, 1)) != DMERR_OK)
 return res;
 // Check for sanity
 if (!iff.chBMHD.count)
 {
 if ((res = dmSkipIFFChunkRest(fp, &chunk)) != DMERR_OK)
 return res;
 if (iff.chCMAP.count)
-parsed = TRUE;
+parsed = true;
 break;
 case IFF_ID_CAMG:
 if (!dmf_read_be32(fp, &iff.camg))
 {
 DMODE_LIT,
 DMODE_RLE,
 };
-static BOOL dmIFFEncodeByteRun1LIT(DMResource *fp,
+static bool dmIFFEncodeByteRun1LIT(DMResource *fp,
 const Uint8 *buf, const size_t offs,
 const size_t count)
 {
 if (count <= 0)
-return TRUE;
+return true;
 Uint8 tmp = count - 1;
 return
 dmf_write_byte(fp, tmp) &&
 dmf_write_str(fp, buf + offs, count);
 }
-static BOOL dmIFFEncodeByteRun1RLE(DMResource *fp,
+static bool dmIFFEncodeByteRun1RLE(DMResource *fp,
 const Uint8 *buf, const size_t offs,
 const size_t count)
 {
 if (count <= 0)
-return TRUE;
+return true;
 Uint8
 tmp = ((Uint8) count - 2) ^ 0xff,
 data = buf[offs];
 dmf_write_byte(fp, tmp) &&
 dmf_write_byte(fp, data);
 }
-BOOL dmIFFEncodeByteRun1Row(DMResource *fp, const Uint8 *buf, const size_t bufLen)
+bool dmIFFEncodeByteRun1Row(DMResource *fp, const Uint8 *buf, const size_t bufLen)
 {
 int prev = -1, mode = DMODE_LIT;
 size_t offs, l_offs, r_offs;
-BOOL ret = TRUE;
+bool ret = true;
 for (offs = l_offs = r_offs = 0; offs < bufLen; offs++)
 {
 Uint8 data = buf[offs];
-BOOL flush = FALSE;
+bool flush = false;
 int pmode = mode;
 if (data == prev)
 {
 if (mode == DMODE_LIT &&
 // Check for last byte of input
 if (offs == bufLen - 1)
 {
 offs++;
-flush = TRUE;
+flush = true;
 pmode = mode;
 }
 if (flush)
 {
 out:
 return ret;
 }
-static BOOL dmIFFWriteOneRow(DMResource *fp, DMIFF *iff, const Uint8 *buf, const size_t bufLen)
+static bool dmIFFWriteOneRow(DMResource *fp, DMIFF *iff, const Uint8 *buf, const size_t bufLen)
 {
 if (iff->bmhd.compression == IFF_COMP_BYTERUN1)
 return dmIFFEncodeByteRun1Row(fp, buf, bufLen);
 else
 return dmf_write_str(fp, buf, bufLen);
 const int ndmImageFormatList = sizeof(dmImageFormatList) / sizeof(dmImageFormatList[0]);
 int dmImageProbeGeneric(const Uint8 *buf, const size_t len, const DMImageFormat **pfmt, int *index)
 {
-int scoreMax = DM_PROBE_SCORE_FALSE, scoreIndex = -1;
+int scoreMax = DM_PROBE_SCORE_false, scoreIndex = -1;
 for (int i = 0; i < ndmImageFormatList; i++)
 {
 const DMImageFormat *fmt = &dmImageFormatList[i];
 if (fmt->probe != NULL)
 *pfmt = &dmImageFormatList[scoreIndex];
 *index = scoreIndex;
 return scoreMax;
 }
 else
-return DM_PROBE_SCORE_FALSE;
+return DM_PROBE_SCORE_false;
 }
 //
 // List of formats
 const int ndmPaletteFormatList = sizeof(dmPaletteFormatList) / sizeof(dmPaletteFormatList[0]);
 int dmPaletteProbeGeneric(const Uint8 *buf, const size_t len, const DMPaletteFormat **pfmt, int *index)
 {
-int scoreMax = DM_PROBE_SCORE_FALSE, scoreIndex = -1;
+int scoreMax = DM_PROBE_SCORE_false, scoreIndex = -1;
 for (int i = 0; i < ndmPaletteFormatList; i++)
 {
 const DMPaletteFormat *fmt = &dmPaletteFormatList[i];
 if (fmt->probe != NULL)
 *pfmt = &dmPaletteFormatList[scoreIndex];
 *index = scoreIndex;
 return scoreMax;
 }
 else
-return DM_PROBE_SCORE_FALSE;
+return DM_PROBE_SCORE_false;
 }

Mercurial > hg > dmlib

comparison tools/libgfx.c @ 2586:9807ae37ad69