Mercurial > hg > dmlib

changeset 1931:410679d2fe8a

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
"Enable" the image->c64 bitmap conversion path in gfxconv. It does not work without the necessary bits elsewhere, though. Also add DMC64ImageConvSpec structure for delivering conversion parameters, though it is not yet used either.
author Matti Hamalainen <ccr@tnsp.org>
date Thu, 28 Jun 2018 17:26:30 +0300
parents c048da352279
children 10e82be38b8b
files tools/64vw.c tools/gfxconv.c tools/lib64fmts.c tools/lib64gfx.c tools/lib64gfx.h
diffstat 5 files changed, 81 insertions(+), 26 deletions(-) [+]
line wrap: on
line diff
--- a/tools/64vw.c	Thu Jun 28 14:49:52 2018 +0300
+++ b/tools/64vw.c	Thu Jun 28 17:26:30 2018 +0300
@@ -208,7 +208,8 @@
 }
 
 
-int dmDecodeC64Image(const DMC64Image *cimage, const DMC64ImageFormat *fmt, SDL_Surface *surf)
+int dmDecodeC64Image(const DMC64Image *cimage, const DMC64ImageFormat *fmt,
+    SDL_Surface *surf, const DMC64ImageConvSpec *spec)
 {
     DMImage bmap;
     int ret;
@@ -224,9 +225,9 @@
     bmap.pal      = dmDefaultC64Palette;
 
     if (fmt->format->convertFrom != NULL)
-        ret = fmt->format->convertFrom(&bmap, cimage, fmt);
+        ret = fmt->format->convertFrom(&bmap, cimage, fmt, spec);
     else
-        ret = dmC64ConvertGenericBMP2Image(&bmap, cimage, fmt);
+        ret = dmC64ConvertGenericBMP2Image(&bmap, cimage, fmt, spec);
 
     SDL_SetPaletteColors(surf->format->palette, (SDL_Color *) bmap.pal, 0, bmap.ncolors);
 
@@ -236,17 +237,19 @@
 
 int main(int argc, char *argv[])
 {
+    const DMC64ImageFormat *forced;
+    DMC64ImageConvSpec spec;
     SDL_Window *window = NULL;
     SDL_Renderer *renderer = NULL;
     SDL_Texture *texture = NULL;
     SDL_Surface *surf = NULL;
     BOOL initSDL = FALSE, exitFlag, needRedraw;
-    const DMC64ImageFormat *forced;
     size_t currIndex, prevIndex;
     int ret;
 
     dmC64InitializeFormats();
     dmSetScaleFactor(2.0);
+    memset(&spec, 0, sizeof(spec));
 
     dmInitProg("64vw", "Display some C64 bitmap graphics formats", "0.4", NULL, NULL);
 
@@ -468,7 +471,7 @@
                 goto exit;
             }
 
-            if (dmDecodeC64Image(cimage, fmt, surf) == DMERR_OK)
+            if (dmDecodeC64Image(cimage, fmt, surf, &spec) == DMERR_OK)
             {
                 title = dm_strdup_printf("%s - [%d / %d] %s (%dx%d @ %s)",
                     dmProgName,
--- a/tools/gfxconv.c	Thu Jun 28 14:49:52 2018 +0300
+++ b/tools/gfxconv.c	Thu Jun 28 17:26:30 2018 +0300
@@ -1786,6 +1786,7 @@
 int main(int argc, char *argv[])
 {
     FILE *inFile = NULL;
+    DMC64ImageConvSpec imageSpecC64;
     const DMC64ImageFormat *inC64Fmt = NULL;
     DMConvFormat inFormat, outFormat;
     DMC64Image *inC64Image = NULL, *outC64Image = NULL;
@@ -1797,6 +1798,9 @@
     for (i = 0; i < C64_NCOLORS; i++)
         optColorMap[i] = i;
 
+    // Initialize c64 image conversion spec
+    memset(&imageSpecC64, 0, sizeof(imageSpecC64));
+
     // Initialize list of additional conversion formats
     dmC64InitializeFormats();
     nconvFormatList = ndmImageFormatList + nbaseFormatList;
@@ -1983,7 +1987,7 @@
                     case FFMT_IMAGE:
                     case FFMT_CHAR:
                     case FFMT_SPRITE:
-                        res = dmC64ConvertBMP2Image(&outImage, inC64Image, inC64Fmt);
+                        res = dmC64ConvertBMP2Image(&outImage, inC64Image, inC64Fmt, &imageSpecC64);
 
                         if (res != DMERR_OK || outImage == NULL)
                         {
@@ -2069,7 +2073,36 @@
 
                     case FFMT_CHAR:
                     case FFMT_SPRITE:
-                        res = dmWriteSpritesAndChars(optOutFilename, inImage, optOutType, optInMulticolor);
+                        res = dmWriteSpritesAndChars(optOutFilename, inImage,
+                            optOutType, optInMulticolor);
+                        break;
+
+                    case FFMT_BITMAP:
+                        {
+                            DMC64Image *tmpC64Image = NULL;
+                            res = dmC64ConvertImage2BMP(&tmpC64Image, inImage,
+                                &dmC64ImageFormats[optOutFormat], &imageSpecC64);
+
+                            if (res != DMERR_OK || tmpC64Image == NULL)
+                            {
+                                dmC64ImageFree(tmpC64Image);
+                                dmErrorMsg("Error in image to bitmap conversion: %s\n",
+                                    dmErrorStr(res));
+                                goto error;
+                            }
+
+                            if ((res = dmConvertC64Bitmap(&outC64Image, tmpC64Image,
+                                &dmC64ImageFormats[optOutFormat], &dmC64ImageFormats[optOutFormat])) != DMERR_OK)
+                            {
+                                dmC64ImageFree(tmpC64Image);
+                                dmErrorMsg("Error in bitmap format conversion: %s\n",
+                                    dmErrorStr(res));
+                                goto error;
+                            }
+
+                            res = dmWriteBitmap(optOutFilename, outC64Image, &dmC64ImageFormats[optOutFormat]);
+                            dmC64ImageFree(tmpC64Image);
+                        }
                         break;
 
                     default:
--- a/tools/lib64fmts.c	Thu Jun 28 14:49:52 2018 +0300
+++ b/tools/lib64fmts.c	Thu Jun 28 17:26:30 2018 +0300
@@ -930,12 +930,13 @@
 }
 
 
-static int fmtConvertECIBMP2Image(DMImage *dst, const DMC64Image *src, const DMC64ImageFormat *fmt)
+static int fmtConvertECIBMP2Image(DMImage *dst, const DMC64Image *src,
+    const DMC64ImageFormat *fmt, const DMC64ImageConvSpec *spec)
 {
     if (!dmSetMixedColorC64Palette(dst))
         return DMERR_MALLOC;
 
-    return dmC64ConvertGenericBMP2Image(dst, src, fmt);
+    return dmC64ConvertGenericBMP2Image(dst, src, fmt, spec);
 }
 
 
--- a/tools/lib64gfx.c	Thu Jun 28 14:49:52 2018 +0300
+++ b/tools/lib64gfx.c	Thu Jun 28 17:26:30 2018 +0300
@@ -1230,12 +1230,13 @@
 
 // Convert a generic "C64" format bitmap in DMC64Image struct to
 // a indexed/paletted bitmap image.
-int dmC64ConvertGenericBMP2Image(DMImage *dst, const DMC64Image *src, const DMC64ImageFormat *fmt)
+int dmC64ConvertGenericBMP2Image(DMImage *dst, const DMC64Image *src,
+    const DMC64ImageFormat *fmt, const DMC64ImageConvSpec *spec)
 {
     DMC64GetPixelFunc getPixel;
 
     // Sanity check arguments
-    if (dst == NULL || src == NULL)
+    if (dst == NULL || src == NULL || fmt == NULL || spec == NULL)
         return DMERR_NULLPTR;
 
     if (dst->width < src->width || dst->height < src->height)
@@ -1358,12 +1359,13 @@
 }
 
 
-int dmC64ConvertBMP2Image(DMImage **pdst, const DMC64Image *src, const DMC64ImageFormat *fmt)
+int dmC64ConvertBMP2Image(DMImage **pdst, const DMC64Image *src,
+    const DMC64ImageFormat *fmt, const DMC64ImageConvSpec *spec)
 {
     int res;
     DMImage *dst;
 
-    if (pdst == NULL || src == NULL)
+    if (pdst == NULL || src == NULL || fmt == NULL || spec == NULL)
         return DMERR_NULLPTR;
 
     // Allocate image structure
@@ -1377,9 +1379,9 @@
 
     // Convert
     if (fmt->format->convertFrom != NULL)
-        res = fmt->format->convertFrom(dst, src, fmt);
+        res = fmt->format->convertFrom(dst, src, fmt, spec);
     else
-        res = dmC64ConvertGenericBMP2Image(dst, src, fmt);
+        res = dmC64ConvertGenericBMP2Image(dst, src, fmt, spec);
 
     return res;
 }
@@ -1433,16 +1435,18 @@
 
 
 // Convert a generic bitmap image to DMC64Image
-int dmC64ConvertGenericImage2BMP(DMC64Image *dst, const DMImage *src, const DMC64ImageFormat *fmt)
+int dmC64ConvertGenericImage2BMP(DMC64Image *dst, const DMImage *src,
+    const DMC64ImageFormat *fmt, const DMC64ImageConvSpec *spec)
 {
-    if (dst == NULL || src == NULL || fmt == NULL)
+    if (dst == NULL || src == NULL || fmt == NULL || spec == NULL)
         return DMERR_NULLPTR;
 
     return DMERR_OK;
 }
 
 
-int dmC64ConvertImage2BMP(DMC64Image **pdst, const DMImage *src, const DMC64ImageFormat *fmt)
+int dmC64ConvertImage2BMP(DMC64Image **pdst, const DMImage *src,
+    const DMC64ImageFormat *fmt, const DMC64ImageConvSpec *spec)
 {
     int res;
     DMC64Image *dst;
@@ -1456,9 +1460,9 @@
 
     // Convert
     if (fmt->format->convertTo != NULL)
-        res = fmt->format->convertTo(dst, src, fmt);
+        res = fmt->format->convertTo(dst, src, fmt, spec);
     else
-        res = dmC64ConvertGenericImage2BMP(dst, src, fmt);
+        res = dmC64ConvertGenericImage2BMP(dst, src, fmt, spec);
 
     return res;
 }
--- a/tools/lib64gfx.h	Thu Jun 28 14:49:52 2018 +0300
+++ b/tools/lib64gfx.h	Thu Jun 28 17:26:30 2018 +0300
@@ -78,6 +78,13 @@
 };
 
 
+// Image <-> bitmap conversion dithering
+enum
+{
+    D64_DITH_NONE = 0,     // No dithering
+};
+
+
 // Different enc/dec operation types (op->type)
 enum
 {
@@ -118,6 +125,13 @@
 
 typedef struct
 {
+    int dither;      // Dither mode (D64_DITH_*)
+    BOOL aspect;     // Correct pixel aspect ratio?
+} DMC64ImageConvSpec;
+
+
+typedef struct
+{
     Uint8 *data;
     size_t size;
 } DMC64MemBlock;
@@ -193,8 +207,8 @@
     int  width, height; // Width and height in pixels
     int  chWidth, chHeight; // Width and height in charblocks
 
-    int  (*convertFrom)(DMImage *, const DMC64Image *, const DMC64ImageFormat *fmt);
-    int  (*convertTo)(DMC64Image *, const DMImage *, const DMC64ImageFormat *fmt);
+    int  (*convertFrom)(DMImage *, const DMC64Image *, const DMC64ImageFormat *fmt, const DMC64ImageConvSpec *spec);
+    int  (*convertTo)(DMC64Image *, const DMImage *, const DMC64ImageFormat *fmt, const DMC64ImageConvSpec *spec);
 
     DMC64GetPixelFunc getPixel;
 
@@ -323,14 +337,14 @@
 int       dmC64DecodeGenericBMP(DMC64Image *img, const DMGrowBuf *buf, const DMC64ImageFormat *fmt);
 int       dmC64EncodeGenericBMP(const BOOL allocate, DMGrowBuf *buf, const DMC64Image *img, const DMC64ImageFormat *fmt);
 
-int       dmC64ConvertBMP2Image(DMImage **pdst, const DMC64Image *src, const DMC64ImageFormat *fmt);
-int       dmC64ConvertImage2BMP(DMC64Image **pdst, const DMImage *src, const DMC64ImageFormat *fmt);
+int       dmC64ConvertBMP2Image(DMImage **pdst, const DMC64Image *src, const DMC64ImageFormat *fmt, const DMC64ImageConvSpec *spec);
+int       dmC64ConvertImage2BMP(DMC64Image **pdst, const DMImage *src, const DMC64ImageFormat *fmt, const DMC64ImageConvSpec *spec);
 
 int       dmC64DecodeBMP(DMC64Image **img, const DMGrowBuf *buf, const size_t probeOffs, const size_t loadOffs, const DMC64ImageFormat **fmt, const DMC64ImageFormat *forced);
 int       dmC64EncodeBMP(DMGrowBuf *buf, const DMC64Image *img, const DMC64ImageFormat *fmt);
 
-int       dmC64ConvertGenericBMP2Image(DMImage *dst, const DMC64Image *src, const DMC64ImageFormat *fmt);
-int       dmC64ConvertGenericImage2BMP(DMC64Image *dst, const DMImage *src, const DMC64ImageFormat *fmt);
+int       dmC64ConvertGenericBMP2Image(DMImage *dst, const DMC64Image *src, const DMC64ImageFormat *fmt, const DMC64ImageConvSpec *spec);
+int       dmC64ConvertGenericImage2BMP(DMC64Image *dst, const DMImage *src, const DMC64ImageFormat *fmt, const DMC64ImageConvSpec *spec);
 
 void      dmGenericRLEAnalyze(const DMGrowBuf *buf, DMCompParams *cfg);