gdisp_image.c

/*
 * This file is subject to the terms of the GFX License. If a copy of
 * the license was not distributed with this file, you can obtain one at:
 *
 *              http://ugfx.io/license.html
 */
 
#include "../../gfx.h"
 
#if GFX_USE_GDISP && GDISP_NEED_IMAGE
 
#include "gdisp_image_support.h"
 
#if GDISP_NEED_IMAGE_NATIVE
    extern gdispImageError gdispImageOpen_NATIVE(gImage *img);
    extern void gdispImageClose_NATIVE(gImage *img);
    extern gdispImageError gdispImageCache_NATIVE(gImage *img);
    extern gdispImageError gdispGImageDraw_NATIVE(GDisplay *g, gImage *img, gCoord x, gCoord y, gCoord cx, gCoord cy, gCoord sx, gCoord sy);
    extern gDelay gdispImageNext_NATIVE(gImage *img);
#endif
 
#if GDISP_NEED_IMAGE_GIF
    extern gdispImageError gdispImageOpen_GIF(gImage *img);
    extern void gdispImageClose_GIF(gImage *img);
    extern gdispImageError gdispImageCache_GIF(gImage *img);
    extern gdispImageError gdispGImageDraw_GIF(GDisplay *g, gImage *img, gCoord x, gCoord y, gCoord cx, gCoord cy, gCoord sx, gCoord sy);
    extern gDelay gdispImageNext_GIF(gImage *img);
#endif
 
#if GDISP_NEED_IMAGE_BMP
    extern gdispImageError gdispImageOpen_BMP(gImage *img);
    extern void gdispImageClose_BMP(gImage *img);
    extern gdispImageError gdispImageCache_BMP(gImage *img);
    extern gdispImageError gdispGImageDraw_BMP(GDisplay *g, gImage *img, gCoord x, gCoord y, gCoord cx, gCoord cy, gCoord sx, gCoord sy);
    extern gDelay gdispImageNext_BMP(gImage *img);
    extern gU16 gdispImageGetPaletteSize_BMP(gImage *img);
    extern gColor gdispImageGetPalette_BMP(gImage *img, gU16 index);
    extern gBool gdispImageAdjustPalette_BMP(gImage *img, gU16 index, gColor newColor);
#endif
 
#if GDISP_NEED_IMAGE_JPG
    extern gdispImageError gdispImageOpen_JPG(gImage *img);
    extern void gdispImageClose_JPG(gImage *img);
    extern gdispImageError gdispImageCache_JPG(gImage *img);
    extern gdispImageError gdispGImageDraw_JPG(GDisplay *g, gImage *img, gCoord x, gCoord y, gCoord cx, gCoord cy, gCoord sx, gCoord sy);
    extern gDelay gdispImageNext_JPG(gImage *img);
#endif
 
#if GDISP_NEED_IMAGE_PNG
    extern gdispImageError gdispImageOpen_PNG(gImage *img);
    extern void gdispImageClose_PNG(gImage *img);
    extern gdispImageError gdispImageCache_PNG(gImage *img);
    extern gdispImageError gdispGImageDraw_PNG(GDisplay *g, gImage *img, gCoord x, gCoord y, gCoord cx, gCoord cy, gCoord sx, gCoord sy);
    extern gDelay gdispImageNext_PNG(gImage *img);
#endif
 
/* The structure defining the routines for image drawing */
typedef struct gdispImageHandlers {
    gdispImageError (*open)(gImage *img);                   /* The open function */
    void            (*close)(gImage *img);                  /* The close function */
    gdispImageError (*cache)(gImage *img);                  /* The cache function */
    gdispImageError (*draw)(GDisplay *g,
                            gImage *img,
                            gCoord x, gCoord y,
                            gCoord cx, gCoord cy,
                            gCoord sx, gCoord sy);          /* The draw function */
    gDelay      (*next)(gImage *img);                   /* The next frame function */
    gU16        (*getPaletteSize)(gImage *img);         /* Retrieve the size of the palette (number of entries) */
    gColor          (*getPalette)(gImage *img, gU16 index);                         /* Retrieve a specific color value of the palette */
    gBool           (*adjustPalette)(gImage *img, gU16 index, gColor newColor); /* Replace a color value in the palette */
} gdispImageHandlers;
 
static gdispImageHandlers ImageHandlers[] = {
    #if GDISP_NEED_IMAGE_NATIVE
        {   gdispImageOpen_NATIVE,  gdispImageClose_NATIVE,
            gdispImageCache_NATIVE, gdispGImageDraw_NATIVE, gdispImageNext_NATIVE,
            0,                      0,                      0
        },
    #endif
    #if GDISP_NEED_IMAGE_GIF
        {   gdispImageOpen_GIF,     gdispImageClose_GIF,
            gdispImageCache_GIF,    gdispGImageDraw_GIF,    gdispImageNext_GIF,
            0,                      0,                      0
        },
    #endif
    #if GDISP_NEED_IMAGE_BMP
        {   gdispImageOpen_BMP,             gdispImageClose_BMP,
            gdispImageCache_BMP,            gdispGImageDraw_BMP,        gdispImageNext_BMP,
            gdispImageGetPaletteSize_BMP,   gdispImageGetPalette_BMP,   gdispImageAdjustPalette_BMP
        },
    #endif
    #if GDISP_NEED_IMAGE_JPG
        {   gdispImageOpen_JPG,     gdispImageClose_JPG,
            gdispImageCache_JPG,    gdispGImageDraw_JPG,    gdispImageNext_JPG,
            0,                      0,                      0
        },
    #endif
    #if GDISP_NEED_IMAGE_PNG
        {   gdispImageOpen_PNG,     gdispImageClose_PNG,
            gdispImageCache_PNG,    gdispGImageDraw_PNG,    gdispImageNext_PNG,
            0,                      0,                      0
        },
    #endif
};
 
void gdispImageInit(gImage *img) {
    img->type = GDISP_IMAGE_TYPE_UNKNOWN;
}
 
gdispImageError gdispImageOpenGFile(gImage *img, GFILE *f) {
    gdispImageError err;
 
    if (!img)
        return GDISP_IMAGE_ERR_NULLPOINTER;
    if (!f)
        return GDISP_IMAGE_ERR_NOSUCHFILE;
    img->f = f;
    img->bgcolor = GFX_WHITE;
    for(img->fns = ImageHandlers; img->fns < ImageHandlers+sizeof(ImageHandlers)/sizeof(ImageHandlers[0]); img->fns++) {
        err = img->fns->open(img);
        if (err != GDISP_IMAGE_ERR_BADFORMAT) {
            if ((err & GDISP_IMAGE_ERR_UNRECOVERABLE))
                goto unrecoverable;
 
            // Everything is possible
            return err;
        }
 
        // Try the next decoder
        gfileSetPos(img->f, 0);
    }
 
    err = GDISP_IMAGE_ERR_BADFORMAT;
    img->type = GDISP_IMAGE_TYPE_UNKNOWN;
 
unrecoverable:
    gfileClose(img->f);
    img->f = 0;
    img->flags = 0;
    img->fns = 0;
    img->priv = 0;
    return err;
}
 
void gdispImageClose(gImage *img) {
    if (!img)
        return;
    if (img->fns)
        img->fns->close(img);
    gfileClose(img->f);
    img->type = GDISP_IMAGE_TYPE_UNKNOWN;
    img->flags = 0;
    img->fns = 0;
    img->priv = 0;
}
 
gBool gdispImageIsOpen(gImage *img) {
    return img && img->type != GDISP_IMAGE_TYPE_UNKNOWN && img->fns != 0;
}
 
void gdispImageSetBgColor(gImage *img, gColor bgcolor) {
    if (!img)
        return;
    img->bgcolor = bgcolor;
}
 
gdispImageError gdispImageCache(gImage *img) {
    if (!img) return GDISP_IMAGE_ERR_NULLPOINTER;
    if (!img->fns) return GDISP_IMAGE_ERR_BADFORMAT;
    return img->fns->cache(img);
}
 
gdispImageError gdispGImageDraw(GDisplay *g, gImage *img, gCoord x, gCoord y, gCoord cx, gCoord cy, gCoord sx, gCoord sy) {
    if (!img) return GDISP_IMAGE_ERR_NULLPOINTER;
    if (!img->fns) return GDISP_IMAGE_ERR_BADFORMAT;
 
    // Check on window
    if (cx <= 0 || cy <= 0) return GDISP_IMAGE_ERR_OK;
    if (sx < 0) sx = 0;
    if (sy < 0) sy = 0;
    if (sx >= img->width || sy >= img->height) return GDISP_IMAGE_ERR_OK;
    if (sx + cx > img->width)  cx = img->width - sx;
    if (sy + cy > img->height) cy = img->height - sy;
 
    // Draw
    return img->fns->draw(g, img, x, y, cx, cy, sx, sy);
}
 
gDelay gdispImageNext(gImage *img) {
    if (!img) return GDISP_IMAGE_ERR_NULLPOINTER;
    if (!img->fns) return GDISP_IMAGE_ERR_BADFORMAT;
    return img->fns->next(img);
}
 
gU16 gdispImageGetPaletteSize(gImage *img) {
    if (!img || !img->fns) return 0;
    if (!img->fns->getPaletteSize) return 0;
    return img->fns->getPaletteSize(img);
}
 
gColor gdispImageGetPalette(gImage *img, gU16 index) {
    if (!img || !img->fns) return 0;
    if (!img->fns->getPalette) return 0;
    return img->fns->getPalette(img, index);
}
 
gBool gdispImageAdjustPalette(gImage *img, gU16 index, gColor newColor) {
    if (!img || !img->fns) return gFalse;
    if (!img->fns->adjustPalette) return gFalse;
    return img->fns->adjustPalette(img, index, newColor);
}
 
 
// Helper Routines
void *gdispImageAlloc(gImage *img, gMemSize sz) {
    #if GDISP_NEED_IMAGE_ACCOUNTING
        void *ptr;
 
        ptr = gfxAlloc(sz);
        if (ptr) {
            img->memused += sz;
            if (img->memused > img->maxmemused)
                img->maxmemused = img->memused;
        }
        return ptr;
    #else
        (void) img;
        return gfxAlloc(sz);
    #endif
}
 
void gdispImageFree(gImage *img, void *ptr, gMemSize sz) {
    #if GDISP_NEED_IMAGE_ACCOUNTING
        gfxFree(ptr);
        img->memused -= sz;
    #else
        (void) img;
        (void) sz;
        gfxFree(ptr);
    #endif
}
 
#if GFX_CPU_ENDIAN != GFX_CPU_ENDIAN_LITTLE && GFX_CPU_ENDIAN != GFX_CPU_ENDIAN_BIG \
        && GFX_CPU_ENDIAN != GFX_CPU_ENDIAN_WBDWL && GFX_CPU_ENDIAN != GFX_CPU_ENDIAN_WLDWB
 
    union wbyteorder_u {
        gU8     b[2];
        gU32    w;
    };
    union dwbyteorder_u {
        gU8     b[4];
        gU32    l;
    };
 
    gU16 gdispImageH16toLE16(gU16 w) {
        union wbyteorder_u  we;
 
        we.w = w;
        return   (((gU16)we.b[0]))|(((gU16)we.b[1]) << 8);
    }
    gU16 gdispImageH16toBE16(gU16 w) {
        union wbyteorder_u  we;
 
        we.w = w;
        return   (((gU16)we.b[0]) << 8)|(((gU16)we.b[1]));
    }
 
    gU32 gdispImageH32toLE32(gU32 dw) {
        union dwbyteorder_u we;
 
        we.l = dw;
        return   (((gU32)we.b[0]))
                |(((gU32)we.b[1]) << 8)
                |(((gU32)we.b[2]) << 16)
                |(((gU32)we.b[3]) << 24);
    }
    gU32 gdispImageH32toBE32(gU32 dw) {
        union dwbyteorder_u we;
 
        we.l = dw;
        return   (((gU32)we.b[0]) << 24)
                |(((gU32)we.b[1]) << 16)
                |(((gU32)we.b[2]) << 8)
                |(((gU32)we.b[3]));
    }
#endif
 
#endif /* GFX_USE_GDISP && GDISP_NEED_IMAGE */