dmlib: gfxconv.c comparison

comparison gfxconv.c @ 409:b529b7e8ff83

Various improvements and cruft cleanups.

author	Matti Hamalainen <ccr@tnsp.org>
date	Sat, 03 Nov 2012 02:40:07 +0200
parents	59244a7ae37f
children	d94f4bcb4be3

comparison

equal deleted inserted replaced

-:37e65cdcc749
+:b529b7e8ff83
 }
 }
 }
-void dmDumpCharASCII(FILE *outFile, const uint8_t *buf, int *offs, int format, BOOL multicolor)
+void dmDumpCharASCII(FILE *outFile, const Uint8 *buf, int *offs, int format, BOOL multicolor)
 {
 int yc;
 for (yc = 0; yc < C64_CHR_HEIGHT; yc++)
 {
 (*offs)++;
 }
 }
-void dmDumpSpriteASCII(FILE *outFile, const uint8_t *buf, int *offs, int format, BOOL multicolor)
+void dmDumpSpriteASCII(FILE *outFile, const Uint8 *buf, int *offs, int format, BOOL multicolor)
 {
 int bufOffs, xc, yc;
 for (bufOffs = yc = 0; yc < C64_SPR_HEIGHT; yc++)
 {
 }
 (*offs)++;
 }
-int dmWriteImageData(DMImage *img, void *cbdata, BOOL (*writeRowCB)(void *, uint8_t *, size_t), int scale, int format)
+int dmWriteImageData(DMImage *img, void *cbdata, BOOL (*writeRowCB)(void *, Uint8 *, size_t), int scale, int format)
 {
 int x, y, yscale, xscale, res = 0, rowSize, rowWidth;
-uint8_t *row = NULL;
+Uint8 *row = NULL;
 // Allocate memory for row buffer
 rowWidth = img->width * scale;
 rowSize = rowWidth * dmImageGetBytesPerPixel(format);
 if ((row = dmMalloc(rowSize + 16)) == NULL)
 {
-res = -16;
+res = DMERR_MALLOC;
 goto done;
 }
 // Generate the image
 for (y = 0; y < img->height; y++)
 {
-uint8_t *ptr = row,
+Uint8 *ptr = row,
 *ptr1 = row,
 *ptr2 = ptr1 + rowWidth,
 *ptr3 = ptr2 + rowWidth;
 for (x = 0; x < img->width; x++)
 {
-uint8_t c = img->data[(y * img->pitch) + x], qr, qg, qb, qa;
+Uint8 c = img->data[(y * img->pitch) + x], qr, qg, qb, qa;
 switch (format)
 {
 case DM_IFMT_PALETTE:
 for (xscale = 0; xscale < scale; xscale++)
 *ptr++ = c;
 for (yscale = 0; yscale < scale; yscale++)
 {
 if (!writeRowCB(cbdata, row, rowSize))
 {
-res = -32;
+res = DMERR_FWRITE;
 goto done;
 }
 }
 }
 DMImage *img;
 FILE *fp;
 } DMRawData;
-static BOOL dmWriteIFFMasterRAWRow(void *cbdata, uint8_t *row, size_t len)
+static BOOL dmWriteIFFMasterRAWRow(void *cbdata, Uint8 *row, size_t len)
 {
 DMRawData *raw = (DMRawData *) cbdata;
 size_t i;
 for (i = 0; i < len; i++)
 {
 }
-return fwrite(row, sizeof(uint8_t), len, raw->fp) == len;
+return fwrite(row, sizeof(Uint8), len, raw->fp) == len;
 }
 int dmWriteIFFMasterRAWImageFILE(FILE *fp, DMImage *img, int scale, int bpp)
 {
 fclose(fp);
 return res;
 }
-static BOOL dmWritePPMRow(void *cbdata, uint8_t *row, size_t len)
+static BOOL dmWritePPMRow(void *cbdata, Uint8 *row, size_t len)
 {
-return fwrite(row, sizeof(uint8_t), len, (FILE *) cbdata) == len;
+return fwrite(row, sizeof(Uint8), len, (FILE *) cbdata) == len;
 }
 int dmWritePPMImageFILE(FILE *fp, DMImage *img, int scale)
 {
 return res;
 }
 #ifdef HAVE_LIBPNG
-static BOOL dmWritePNGRow(void *cbdata, uint8_t *row, size_t len)
+static BOOL dmWritePNGRow(void *cbdata, Uint8 *row, size_t len)
 {
 png_structp png_ptr = cbdata;
 (void) len;
 if (setjmp(png_jmpbuf(png_ptr)))
 #endif
 typedef struct
 {
-uint8_t r,g,b;
+Uint8 r,g,b;
 } DMPCXColor;
 typedef struct
 {
-uint8_t manufacturer,
+Uint8 manufacturer,
 version,
 encoding,
 bpp;
-uint16_t xmin, ymin, xmax, ymax;
+Uint16 xmin, ymin, xmax, ymax;
-uint16_t hres, vres;
+Uint16 hres, vres;
 DMPCXColor colormap[16];
-uint8_t reserved;
+Uint8 reserved;
-uint8_t nplanes;
+Uint8 nplanes;
-uint16_t bpl;
+Uint16 bpl;
-uint16_t palinfo;
+Uint16 palinfo;
-uint8_t filler[58];
+Uint8 filler[58];
 } DMPCXHeader;
 typedef struct
 {
 DMPCXHeader *header;
-uint8_t *buf;
+Uint8 *buf;
 size_t bufLen, bufOffs;
 int format;
 FILE *fp;
 } DMPCXData;
-static inline uint8_t dmPCXGetByte(uint8_t *row, const size_t len, const size_t soffs)
+static inline Uint8 dmPCXGetByte(Uint8 *row, const size_t len, const size_t soffs)
 {
 return (soffs < len) ? row[soffs] : 0;
 }
 static BOOL dmPCXFlush(DMPCXData *pcx)
 {
-BOOL ret = fwrite(pcx->buf, sizeof(uint8_t), pcx->bufOffs, pcx->fp) == pcx->bufOffs;
+BOOL ret = fwrite(pcx->buf, sizeof(Uint8), pcx->bufOffs, pcx->fp) == pcx->bufOffs;
 pcx->bufOffs = 0;
 return ret;
 }
-static inline BOOL dmPCXPutByte(DMPCXData *pcx, const uint8_t val)
+static inline BOOL dmPCXPutByte(DMPCXData *pcx, const Uint8 val)
 {
 if (pcx->bufOffs < pcx->bufLen)
 {
 pcx->buf[pcx->bufOffs++] = val;
 return TRUE;
 }
 else
 return dmPCXFlush(pcx);
 }
-BOOL dmWritePCXRow(void *cbdata, uint8_t *row, size_t len)
+BOOL dmWritePCXRow(void *cbdata, Uint8 *row, size_t len)
 {
 DMPCXData *pcx = (DMPCXData *) cbdata;
 int plane;
 size_t soffs = 0;
 for (plane = 0; plane < pcx->header->nplanes; plane++)
 {
-uint8_t data = dmPCXGetByte(row, len, soffs++),
+Uint8 data = dmPCXGetByte(row, len, soffs++),
 count = 1;
 pcx->bufOffs = 0;
 while (soffs < pcx->header->bpl)
 pcx.format = paletted ? DM_IFMT_PALETTE : DM_IFMT_RGB_PLANE;
 pcx.header = &hdr;
 if ((pcx.fp = fopen(filename, "wb")) == NULL)
 {
 dmError("PCX: Could not open file '%s' for writing.\n", filename);
-res = -15;
+res = DMERR_FOPEN;
 goto error;
 }
 // Create PCX header
 memset(&hdr, 0, sizeof(hdr));
 pcx.bufLen       = hdr.bpl * 4;
 if ((pcx.buf = dmMalloc(pcx.bufLen)) == NULL)
 {
 dmError("PCX: Could not allocate %d bytes for RLE compression buffer.\n",
 pcx.bufLen);
-res = -11;
+res = DMERR_MALLOC;
 goto error;
 }
 // Write PCX header
 if (!dm_fwrite_byte(pcx.fp, hdr.manufacturer) ||
 !dm_fwrite_byte(pcx.fp, hdr.version) ||
 !dm_fwrite_byte(pcx.fp, hdr.encoding) ||
 !dm_fwrite_byte(pcx.fp, hdr.bpp))
 {
 dmError("PCX: Could not write basic header data.\n");
-res = -10;
+res = DMERR_FWRITE;
 goto error;
 }
 if (!dm_fwrite_le16(pcx.fp, hdr.xmin) ||
 !dm_fwrite_le16(pcx.fp, hdr.ymin) ||
 !dm_fwrite_le16(pcx.fp, hdr.ymax) ||
 !dm_fwrite_le16(pcx.fp, hdr.hres) ||
 !dm_fwrite_le16(pcx.fp, hdr.vres))
 {
 dmError("PCX: Could not write image dimensions.\n");
-res = -9;
+res = DMERR_FWRITE;
 goto error;
 }
-if (!dm_fwrite_str(pcx.fp, (uint8_t *) &hdr.colormap, sizeof(hdr.colormap)))
+if (!dm_fwrite_str(pcx.fp, (Uint8 *) &hdr.colormap, sizeof(hdr.colormap)))
 {
 dmError("PCX: Could not write colormap.\n");
-res = -8;
+res = DMERR_FWRITE;
 goto error;
 }
 if (!dm_fwrite_byte(pcx.fp, hdr.reserved) ||
 !dm_fwrite_byte(pcx.fp, hdr.nplanes) ||
 !dm_fwrite_le16(pcx.fp, hdr.bpl) ||
 !dm_fwrite_le16(pcx.fp, hdr.palinfo) ||
-!dm_fwrite_str(pcx.fp, (uint8_t *) &hdr.filler, sizeof(hdr.filler)))
+!dm_fwrite_str(pcx.fp, (Uint8 *) &hdr.filler, sizeof(hdr.filler)))
 {
 dmError("PCX: Could not write header remainder.\n");
-res = -7;
+res = DMERR_FWRITE;
 goto error;
 }
 // Write image data
 res = dmWriteImageData(img, (void *) &pcx, dmWritePCXRow, scale, pcx.format);
 return res;
 }
-static BOOL dmPCXDecodeRLERow(FILE *fp, uint8_t *buf, const size_t bufLen)
+static BOOL dmPCXDecodeRLERow(FILE *fp, Uint8 *buf, const size_t bufLen)
 {
 size_t offs = 0;
 do
 {
 int count;
-uint8_t data;
+Uint8 data;
 if (!dm_fread_byte(fp, &data))
 return FALSE;
 if ((data & 0xC0) == 0xC0)
 DMImage *img;
 DMPCXData pcx;
 DMPCXHeader hdr;
 BOOL paletted;
 int res = 0, yc, xc;
-uint8_t *dp;
+Uint8 *dp;
 pcx.buf = NULL;
 // Read PCX header
 if (!dm_fread_byte(fp, &hdr.manufacturer) ||
 !dm_fread_byte(fp, &hdr.version) ||
 !dm_fread_byte(fp, &hdr.encoding) ||
 !dm_fread_byte(fp, &hdr.bpp))
 {
 dmError("PCX: Could not read basic header data.\n");
-res = -9;
+res = DMERR_FREAD;
+goto error;
 }
 if (hdr.manufacturer != 10 ||
 hdr.version != 5 ||
 hdr.encoding != 1 ||
 hdr.bpp != 8)
 {
 dmError("PCX: Not a PCX file, or unsupported variant.\n");
-res = -11;
+res = DMERR_FREAD;
 goto error;
 }
 if (!dm_fread_le16(fp, &hdr.xmin) ||
 !dm_fread_le16(fp, &hdr.ymin) ||
 !dm_fread_le16(fp, &hdr.ymax) ||
 !dm_fread_le16(fp, &hdr.hres) ||
 !dm_fread_le16(fp, &hdr.vres))
 {
 dmError("PCX: Could not read image dimensions.\n");
-res = -8;
+res = DMERR_FREAD;
 goto error;
 }
-if (!dm_fread_str(fp, (uint8_t *) &hdr.colormap, sizeof(hdr.colormap)))
+if (!dm_fread_str(fp, (Uint8 *) &hdr.colormap, sizeof(hdr.colormap)))
 {
 dmError("PCX: Could not read colormap.\n");
-res = -7;
+res = DMERR_FREAD;
 goto error;
 }
 if (!dm_fread_byte(fp, &hdr.reserved) ||
 !dm_fread_byte(fp, &hdr.nplanes) ||
 !dm_fread_le16(fp, &hdr.bpl) ||
 !dm_fread_le16(fp, &hdr.palinfo) ||
-!dm_fread_str(fp, (uint8_t *) &hdr.filler, sizeof(hdr.filler)))
+!dm_fread_str(fp, (Uint8 *) &hdr.filler, sizeof(hdr.filler)))
 {
 dmError("PCX: Could not read header remainder.\n");
-res = -6;
+res = DMERR_FREAD;
 goto error;
 }
 if (hdr.nplanes != 3 && hdr.nplanes != 1)
 {
 dmError("PCX: Unsupported number of bitplanes %d.\n", hdr.nplanes);
-res = -4;
+res = DMERR_FREAD;
 goto error;
 }
 // Allocate image
 if ((*pimg = img = dmImageAlloc(hdr.xmax - hdr.xmin + 1, hdr.ymax - hdr.ymin + 1)) == NULL)
 {
 dmError("PCX: Could not allocate image structure.\n");
-res = -5;
+res = DMERR_MALLOC;
 goto error;
 }
 paletted = hdr.nplanes == 1;
 pcx.bufLen = hdr.nplanes * hdr.bpl;
 if ((pcx.buf = dmMalloc(pcx.bufLen)) == NULL)
 {
 dmError("PCX: Could not allocate RLE buffer.\n");
-res = -3;
+res = DMERR_MALLOC;
 goto error;
 }
 // Read image data
 dp = img->data;
 {
 // Decode row of RLE'd data
 if (!dmPCXDecodeRLERow(fp, pcx.buf, pcx.bufLen))
 {
 dmError("PCX: Error decoding RLE data.\n");
-res = -100;
+res = DMERR_INVALID_DATA;
 goto error;
 }
 // Decode bitplanes
 switch (hdr.nplanes)
 memcpy(dp, pcx.buf, img->width);
 break;
 case 3:
 {
-uint8_t *dptr = dp,
+Uint8 *dptr = dp,
 *sptr1 = pcx.buf,
 *sptr2 = sptr1 + hdr.bpl,
 *sptr3 = sptr2 + hdr.bpl;
 for (xc = 0; xc < img->width; xc++)
 // Read VGA palette
 if (paletted)
 {
 int i;
-uint8_t tmpb;
+Uint8 tmpb;
+BOOL read;
 if (!dm_fread_byte(fp, &tmpb) || tmpb != 0x0C)
+{
+read = FALSE;
+img->ncolors = 16;
+}
+else
+{
+read = TRUE;
+img->ncolors = 256;
+}
+if ((img->pal = dmCalloc(img->ncolors, sizeof(DMColor))) == NULL)
+{
+dmError("PCX: Could not allocate palette data!\n");
+res = DMERR_MALLOC;
 goto error;
+}
-for (i = 0; i < img->ncolors; i++)
-{
+if (read)
-if (!dm_fread_byte(fp, &tmpb))
+{
-goto error;
+for (i = 0; i < img->ncolors; i++)
-img->pal[i].r = tmpb;
+{
+Uint8 tmpR, tmpG, tmpB;
-if (!dm_fread_byte(fp, &tmpb))
+if (!dm_fread_byte(fp, &tmpR) ||
-goto error;
+!dm_fread_byte(fp, &tmpG) ||
-img->pal[i].g = tmpb;
+!dm_fread_byte(fp, &tmpB))
+goto error;
-if (!dm_fread_byte(fp, &tmpb))
-goto error;
+img->pal[i].r = tmpR;
-img->pal[i].b = tmpb;
+img->pal[i].g = tmpG;
-}
+img->pal[i].b = tmpB;
+}
+}
+else
+{
+for (i = 0; i < img->ncolors; i++)
+{
+if (i < 16)
+{
+img->pal[i].r = hdr.colormap[i].r;
+img->pal[i].g = hdr.colormap[i].g;
+img->pal[i].b = hdr.colormap[i].b;
+}
+}
+}
 }
 error:
 dmFree(pcx.buf);
 return res;
 }
 int fmtProbePNGImageFILE(FILE *fp)
 {
-uint8_t buf[6];
+Uint8 buf[6];
 //    if (!dm_fread_str(fp,
 return DM_PROBE_SCORE_FALSE;
 }
 #ifdef UNFINISHED
 int dmConvertBMP2(DMImage *screen, const DM64Image *img)
 {
 int yc;
-uint8_t *dp = screen->data;
+Uint8 *dp = screen->data;
 for (yc = 0; yc < screen->height; yc++)
 {
-uint8_t *d = dp;
+Uint8 *d = dp;
 const int y = yc / 8, yb = yc & 7;
 const int scroffsy = y * C64_SCR_CH_WIDTH;
 const int bmoffsy = y * C64_SCR_WIDTH;
 int xc;
 {
 const int x = xc / 4;
 const int scroffs = scroffsy + x;
 const int b = img->bitmap[0][bmoffsy + (x * 8) + yb];
 const int v = 6 - ((xc * 2) & 6);
-uint8_t c;
+Uint8 c;
 switch ((b >> v) & 3)
 {
 case 0: c = img->bgcolor; break;
 case 1: c = img->screen[0][scroffs] >> 4; break;
 {
 int res;
 char *palFilename = dm_strdup_printf("%s.pal", filename);
 res = dmWriteIFFMasterRAWPalette(palFilename, image, 1 << bpp);
 dmFree(palFilename);
-if (res != 0)
+if (res != DMERR_OK)
 return res;
 return dmWriteIFFMasterRAWImage(filename, image, scale, bpp);
 }
 int dmDumpSpritesAndChars(FILE *inFile)
 {
 int dataOffs, itemCount, outWidth, outWidthPX, outHeight;
 size_t bufSize;
-uint8_t *bufData;
+Uint8 *bufData;
 switch (optInFormat)
 {
 case INFMT_CHAR:
 bufSize = C64_CHR_SIZE;
 {
 DMImage *outImage = NULL;
 char *outFilename = NULL;
 int outX = 0, outY = 0, err;
-#ifndef HAVE_LIBPNG
-if (optOutFormat == OUTFMT_PNG)
-{
-dmError("PNG output format support not compiled in, sorry.\n");
-goto error;
-}
-#endif
 if (optSequential)
 {
 if (optOutFilename == NULL)
 {
 dmError("Sequential image output requires filename template.\n");
 bufSize, dataOffs);
 break;
 }
 if ((err = dmC64ConvertCSData(outImage, outX * outWidthPX, outY * outHeight,
-bufData, outWidth, outHeight, optInMulticolor, optColors)) != 0)
+bufData, outWidth, outHeight, optInMulticolor, optColors)) != DMERR_OK)
 {
 dmError("Internal error in conversion of raw data to bitmap: %d.\n", err);
 break;
 }
 dmInitProg("gfxconv", "Simple c64 graphics converter", "0.4", NULL, NULL);
 if (!dmArgsProcess(argc, argv, optList, optListN,
 argHandleOpt, argHandleFile, TRUE))
 exit(1);
+#ifndef HAVE_LIBPNG
+if (optOutFormat == OUTFMT_PNG)
+{
+dmError("PNG output format support not compiled in, sorry.\n");
+exit(3);
+}
+#endif
 // Determine input format, if not specified'
 if (optInFormat == INFMT_AUTO && optInFilename != NULL)
 {
 char *dext = strrchr(optInFilename, '.');
 break;
 case OUTFMT_PNG:
 //                        res = dmReadPNGImageFILE(inFile, &img);
 break;
 }
+if (res != DMERR_OK)
+break;
 switch (optOutFormat)
 {
 case OUTFMT_PCX:
 case OUTFMT_PPM:

Mercurial > hg > dmlib

comparison gfxconv.c @ 409:b529b7e8ff83