usbloadergx/source/libwiigui/gui_imagedata.cpp

/****************************************************************************
 * libwiigui
 *
 * Tantric 2009
 *
 * gui_imagedata.cpp
 *
 * LoadJpeg copyright by r-win for WiiXplorer
 * check WiiXplorer source for license conditions
 *
 * GUI class definitions
 ***************************************************************************/

#include "gui.h"

#ifdef __cplusplus
extern "C"
{
#endif

#include <jpeglib.h>

#ifdef __cplusplus
}
#endif

#define new_width 640
#define new_height 480

/**
 * Constructor for the GuiImageData class.
 */

extern int idiotFlag;
extern char idiotChar[50];
GuiImageData::GuiImageData(const u8 * img)
{
    data = NULL;
    width = 0;
    height = 0;

    if (img)
    {
        PNGUPROP imgProp;
        IMGCTX ctx = PNGU_SelectImageFromBuffer(img);

        if (!ctx) return;

        int res = PNGU_GetImageProperties(ctx, &imgProp);
        //if (((4%imgProp.imgWidth)!=0)||((4%imgProp.imgHeight)!=0))idiotFlag=1;

        if (res == PNGU_OK)
        {
            int len = imgProp.imgWidth * imgProp.imgHeight * 4;
            if (len % 32) len += (32 - len % 32);
            data = (u8 *) memalign(32, len);

            if (data)
            {
                res = PNGU_DecodeTo4x4RGBA8(ctx, imgProp.imgWidth, imgProp.imgHeight, data, 255);

                if (res == PNGU_OK)
                {
                    width = imgProp.imgWidth;
                    height = imgProp.imgHeight;
                    DCFlushRange(data, len);
                }
                else
                {
                    free(data);
                    data = NULL;
                    idiotFlag = 1;
                    snprintf(idiotChar, sizeof(idiotChar), "%s", img);

                }
            }
        }
        PNGU_ReleaseImageContext(ctx);
    }
}

GuiImageData::GuiImageData(const u8 * img, int imgSize)
{
    data = NULL;
    width = 0;
    height = 0;

    if (img)
    {
        if (img[0] == 0xFF && img[1] == 0xD8) // IMAGE_JPEG
        {
            LoadJpeg(img, imgSize);
        }
    }
}
/**
 * Constructor for the GuiImageData class.
 */
GuiImageData::GuiImageData(const char * imgPath, const u8 * buffer)
{
    data = NULL;
    width = 0;
    height = 0;

    if (imgPath)
    {
        PNGUPROP imgProp;
        IMGCTX ctx = PNGU_SelectImageFromDevice(imgPath);
        //if (((4%imgProp.imgWidth)!=0)||((4%imgProp.imgHeight)!=0))idiotFlag=1;

        if (ctx)
        {
            int res = PNGU_GetImageProperties(ctx, &imgProp);

            if (res == PNGU_OK)
            {
                int len = imgProp.imgWidth * imgProp.imgHeight * 4;
                if (len % 32) len += (32 - len % 32);
                data = (u8 *) memalign(32, len);

                if (data)
                {
                    res = PNGU_DecodeTo4x4RGBA8(ctx, imgProp.imgWidth, imgProp.imgHeight, data, 255);

                    if (res == PNGU_OK)
                    {
                        width = imgProp.imgWidth;
                        height = imgProp.imgHeight;
                        DCFlushRange(data, len);
                    }
                    else
                    {
                        free(data);
                        data = NULL;
                        idiotFlag = 1;
                        snprintf(idiotChar, sizeof(idiotChar), "%s", imgPath);
                    }
                }
            }
            PNGU_ReleaseImageContext(ctx);
        }
    }

    if (!data) //use buffer data instead
    {
        width = 0;
        height = 0;
        if (buffer)
        {
            PNGUPROP imgProp;
            IMGCTX ctx = PNGU_SelectImageFromBuffer(buffer);

            if (!ctx) return;

            int res = PNGU_GetImageProperties(ctx, &imgProp);

            if (res == PNGU_OK)
            {
                int len = imgProp.imgWidth * imgProp.imgHeight * 4;
                if (len % 32) len += (32 - len % 32);
                data = (u8 *) memalign(32, len);

                if (data)
                {
                    res = PNGU_DecodeTo4x4RGBA8(ctx, imgProp.imgWidth, imgProp.imgHeight, data, 255);

                    if (res == PNGU_OK)
                    {
                        width = imgProp.imgWidth;
                        height = imgProp.imgHeight;
                        DCFlushRange(data, len);
                    }
                    else
                    {
                        free(data);
                        data = NULL;
                    }
                }
            }
            PNGU_ReleaseImageContext(ctx);
        }
    }
}

/**
 * Constructor for the GuiImageData class.
 */
GuiImageData::GuiImageData(const char *path, const char *file, const u8 *buffer, bool force_widescreen/*=false*/,
        const u8 *wbuffer/*=NULL*/)
{
    data = NULL;
    width = 0;
    height = 0;
    char path_4_3[100];
    char path_16_9[100];
    char *imgPath;

    snprintf(path_4_3, sizeof(path_4_3), "%s%s", path, file);
    if (force_widescreen)
    {
        snprintf(path_16_9, sizeof(path_16_9), "%sw%s", path, file);
        imgPath = path_16_9;
        if (wbuffer) buffer = wbuffer;
    }
    else imgPath = path_4_3;

    for (;;)
    {
        if (imgPath)
        {
            PNGUPROP imgProp;
            IMGCTX ctx = PNGU_SelectImageFromDevice(imgPath);
            //if (((4%imgProp.imgWidth)!=0)||((4%imgProp.imgHeight)!=0))idiotFlag=1;

            if (ctx)
            {
                int res = PNGU_GetImageProperties(ctx, &imgProp);

                if (res == PNGU_OK)
                {
                    int len = imgProp.imgWidth * imgProp.imgHeight * 4;
                    if (len % 32) len += (32 - len % 32);
                    data = (u8 *) memalign(32, len);

                    if (data)
                    {
                        res = PNGU_DecodeTo4x4RGBA8(ctx, imgProp.imgWidth, imgProp.imgHeight, data, 255);

                        if (res == PNGU_OK)
                        {
                            width = imgProp.imgWidth;
                            height = imgProp.imgHeight;
                            DCFlushRange(data, len);
                        }
                        else
                        {
                            free(data);
                            data = NULL;
                            idiotFlag = 1;
                            snprintf(idiotChar, sizeof(idiotChar), "%s", imgPath);
                        }
                    }
                }
                PNGU_ReleaseImageContext(ctx);
            }
        }
        if (data || imgPath == path_4_3) break;
        imgPath = path_4_3;
    }

    if (!data) //use buffer data instead
    {
        width = 0;
        height = 0;
        if (buffer)
        {
            PNGUPROP imgProp;
            IMGCTX ctx = PNGU_SelectImageFromBuffer(buffer);

            if (!ctx) return;

            int res = PNGU_GetImageProperties(ctx, &imgProp);

            if (res == PNGU_OK)
            {
                int len = imgProp.imgWidth * imgProp.imgHeight * 4;
                if (len % 32) len += (32 - len % 32);
                data = (u8 *) memalign(32, len);

                if (data)
                {
                    res = PNGU_DecodeTo4x4RGBA8(ctx, imgProp.imgWidth, imgProp.imgHeight, data, 255);

                    if (res == PNGU_OK)
                    {
                        width = imgProp.imgWidth;
                        height = imgProp.imgHeight;
                        DCFlushRange(data, len);
                    }
                    else
                    {
                        free(data);
                        data = NULL;
                    }
                }
            }
            PNGU_ReleaseImageContext(ctx);
        }
    }
}

/**
 * Destructor for the GuiImageData class.
 */
GuiImageData::~GuiImageData()
{
    if (data)
    {
        free(data);
        data = NULL;
    }
}

u8 * GuiImageData::GetImage()
{
    return data;
}

int GuiImageData::GetWidth()
{
    return width;
}

int GuiImageData::GetHeight()
{
    return height;
}
void GuiImageData::SetGrayscale(void)
{
    GXColor color;
    u32 offset, gray;

    for (int x = 0; x < width; x++)
    {
        for (int y = 0; y < height; y++)
        {
            offset = (((y >> 2) << 4) * width) + ((x >> 2) << 6) + (((y % 4 << 2) + x % 4) << 1);
            color.r = *(data + offset + 1);
            color.g = *(data + offset + 32);
            color.b = *(data + offset + 33);

            gray = (77 * color.r + 150 * color.g + 28 * color.b) / 255;

            *(data + offset + 1) = gray;
            *(data + offset + 32) = gray;
            *(data + offset + 33) = gray;
        }
    }
}

// This function finds it's origin in GRRLIB, which can be found here: http://code.google.com/p/grrlib/
void GuiImageData::LoadJpeg(const u8 *img, int imgSize)
{
    struct jpeg_decompress_struct cinfo;
    struct jpeg_error_mgr jerr;

    int n = imgSize;

    while (n > 1)
    {
        if (img[n - 1] == 0xff && img[n] == 0xd9)
        {
            break;
        }
        n--;
    }

    jpeg_create_decompress( &cinfo );
    cinfo.err = jpeg_std_error(&jerr);
    cinfo.progress = NULL;
    jpeg_mem_src(&cinfo, (u8 *) img, n);
    jpeg_read_header(&cinfo, TRUE);
    jpeg_calc_output_dimensions(&cinfo);

    if (cinfo.output_width > new_width || cinfo.output_height > new_height)
    {
        float factor = (cinfo.output_width > cinfo.output_height) ? (1.0 * cinfo.output_width) / new_width : (1.0
                * cinfo.output_height) / new_height;
        cinfo.scale_num = 1;
        cinfo.scale_denom = factor;
        cinfo.do_fancy_upsampling = true;
        cinfo.do_block_smoothing = false;
        cinfo.dct_method = JDCT_IFAST;
    }

    jpeg_start_decompress(&cinfo);

    int rowsize = cinfo.output_width * cinfo.num_components;
    unsigned char *tempBuffer = (unsigned char *) malloc(rowsize * cinfo.output_height);

    JSAMPROW row_pointer[1];

    row_pointer[0] = (unsigned char*) malloc(rowsize);
    size_t location = 0;
    while (cinfo.output_scanline < cinfo.output_height)
    {
        jpeg_read_scanlines(&cinfo, row_pointer, 1);
        memcpy(tempBuffer + location, row_pointer[0], rowsize);
        location += rowsize;
    }

    int len = ((cinfo.output_width + 3) >> 2) * ((cinfo.output_height + 3) >> 2) * 32 * 2;

    data = (u8 *) memalign(32, len);

    RawTo4x4RGBA(tempBuffer, data, cinfo.output_width, cinfo.output_height);
    DCFlushRange(data, len);

    width = cinfo.output_width;
    height = cinfo.output_height;

    jpeg_finish_decompress(&cinfo);
    jpeg_destroy_decompress(&cinfo);
    free(row_pointer[0]);
    free(tempBuffer);
}

/**
 * Convert a raw bmp (RGB, no alpha) to 4x4RGBA.
 * @author DragonMinded
 * @param src
 * @param dst
 * @param width
 * @param height
 */
void GuiImageData::RawTo4x4RGBA(const unsigned char *src, void *dst, const unsigned int width,
        const unsigned int height)
{
    unsigned int block;
    unsigned int i;
    unsigned int c;
    unsigned int ar;
    unsigned int gb;
    unsigned char *p = (unsigned char*) dst;

    for (block = 0; block < height; block += 4)
    {
        for (i = 0; i < width; i += 4)
        {
            /* Alpha and Red */
            for (c = 0; c < 4; ++c)
            {
                for (ar = 0; ar < 4; ++ar)
                {
                    /* Alpha pixels */
                    *p++ = 255;
                    /* Red pixels */
                    *p++ = src[((i + ar) + ((block + c) * width)) * 3];
                }
            }

            /* Green and Blue */
            for (c = 0; c < 4; ++c)
            {
                for (gb = 0; gb < 4; ++gb)
                {
                    /* Green pixels */
                    *p++ = src[(((i + gb) + ((block + c) * width)) * 3) + 1];
                    /* Blue pixels */
                    *p++ = src[(((i + gb) + ((block + c) * width)) * 3) + 2];
                }
            }
        } /* i */
    } /* block */
}