/*
 * Copyright 2006-2023 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Stephan Aßmus, superstippi@gmx.de
 *              Axel Dörfler, axeld@pinc-software.de
 *              John Scipione, jscipione@gmail.com
 *              Ingo Weinhold, bonefish@cs.tu-berlin.de
 */


#include "IconUtils.h"

#include <new>
#include <fs_attr.h>
#include <stdio.h>
#include <string.h>

#include <Bitmap.h>
#include <FindDirectory.h>
#include <Node.h>
#include <NodeInfo.h>
#include <Path.h>
#include <Resources.h>
#include <String.h>
#include <TypeConstants.h>

#include "AutoDeleter.h"
#include "Icon.h"
#include "IconRenderer.h"
#include "FlatIconImporter.h"
#include "MessageImporter.h"


#define B_MINI_ICON_TYPE        'MICN'
#define B_LARGE_ICON_TYPE       'ICON'


_USING_ICON_NAMESPACE;


//      #pragma mark - Scaling functions


static void
scale_bilinear(uint8* bits, int32 srcWidth, int32 srcHeight, int32 dstWidth,
        int32 dstHeight, uint32 bpr)
{
        // first pass: scale bottom to top

        uint8* dst = bits + (dstHeight - 1) * bpr;
                // offset to bottom left pixel in target size
        for (int32 x = 0; x < srcWidth; x++) {
                uint8* d = dst;
                for (int32 y = dstHeight - 1; y >= 0; y--) {
                        int32 lineF = (y << 8) * (srcHeight - 1) / (dstHeight - 1);
                        int32 lineI = lineF >> 8;
                        uint8 weight = (uint8)(lineF & 0xff);
                        uint8* s1 = bits + lineI * bpr + 4 * x;
                        if (weight == 0) {
                                d[0] = s1[0];
                                d[1] = s1[1];
                                d[2] = s1[2];
                                d[3] = s1[3];
                        } else {
                                uint8* s2 = s1 + bpr;

                                d[0] = (((s2[0] - s1[0]) * weight) + (s1[0] << 8)) >> 8;
                                d[1] = (((s2[1] - s1[1]) * weight) + (s1[1] << 8)) >> 8;
                                d[2] = (((s2[2] - s1[2]) * weight) + (s1[2] << 8)) >> 8;
                                d[3] = (((s2[3] - s1[3]) * weight) + (s1[3] << 8)) >> 8;
                        }

                        d -= bpr;
                }
                dst += 4;
        }

        // second pass: scale right to left

        dst = bits + (dstWidth - 1) * 4;
                // offset to top left pixel in target size
        for (int32 y = 0; y < dstWidth; y++) {
                uint8* d = dst;
                for (int32 x = dstWidth - 1; x >= 0; x--) {
                        int32 columnF = (x << 8) * (srcWidth - 1) / (dstWidth - 1);
                        int32 columnI = columnF >> 8;
                        uint8 weight = (uint8)(columnF & 0xff);
                        uint8* s1 = bits + y * bpr + 4 * columnI;
                        if (weight == 0) {
                                d[0] = s1[0];
                                d[1] = s1[1];
                                d[2] = s1[2];
                                d[3] = s1[3];
                        } else {
                                uint8* s2 = s1 + 4;

                                d[0] = (((s2[0] - s1[0]) * weight) + (s1[0] << 8)) >> 8;
                                d[1] = (((s2[1] - s1[1]) * weight) + (s1[1] << 8)) >> 8;
                                d[2] = (((s2[2] - s1[2]) * weight) + (s1[2] << 8)) >> 8;
                                d[3] = (((s2[3] - s1[3]) * weight) + (s1[3] << 8)) >> 8;
                        }

                        d -= 4;
                }
                dst += bpr;
        }
}


static void
scale_down(const uint8* srcBits, uint8* dstBits, int32 srcWidth, int32 srcHeight,
        int32 dstWidth, int32 dstHeight)
{
        int32 l;
        int32 c;
        float t;
        float u;
        float tmp;
        float d1, d2, d3, d4;
                // coefficients
        rgb_color p1, p2, p3, p4;
                // nearby pixels
        rgb_color out;
                // color components

        for (int32 i = 0; i < dstHeight; i++) {
                for (int32 j = 0; j < dstWidth; j++) {
                        tmp = (float)(i) / (float)(dstHeight - 1) * (srcHeight - 1);
                        l = (int32)floorf(tmp);
                        if (l < 0)
                                l = 0;
                        else if (l >= srcHeight - 1)
                                l = srcHeight - 2;
                        u = tmp - l;

                        tmp = (float)(j) / (float)(dstWidth - 1) * (srcWidth - 1);
                        c = (int32)floorf(tmp);
                        if (c < 0)
                                c = 0;
                        else if (c >= srcWidth - 1)
                                c = srcWidth - 2;
                        t = tmp - c;

                        // coefficients
                        d1 = (1 - t) * (1 - u);
                        d2 = t * (1 - u);
                        d3 = t * u;
                        d4 = (1 - t) * u;

                        // nearby pixels
                        p1 = *((rgb_color*)srcBits + (l * srcWidth) + c);
                        p2 = *((rgb_color*)srcBits + (l * srcWidth) + c + 1);
                        p3 = *((rgb_color*)srcBits + ((l + 1) * srcWidth) + c + 1);
                        p4 = *((rgb_color*)srcBits + ((l + 1) * srcWidth) + c);

                        // color components
                        out.blue = (uint8)(p1.blue * d1 + p2.blue * d2 + p3.blue * d3
                                + p4.blue * d4);
                        out.green = (uint8)(p1.green * d1 + p2.green * d2 + p3.green * d3
                                + p4.green * d4);
                        out.red = (uint8)(p1.red * d1 + p2.red * d2 + p3.red * d3
                                + p4.red * d4);
                        out.alpha = (uint8)(p1.alpha * d1 + p2.alpha * d2 + p3.alpha * d3
                                + p4.alpha * d4);

                        // destination RGBA pixel
                        *((rgb_color*)dstBits + (i * dstWidth) + j) = out;
                }
        }
}


static void
scale2x(const uint8* srcBits, uint8* dstBits, int32 srcWidth, int32 srcHeight,
        int32 srcBPR, int32 dstBPR)
{
        /*
         * This implements the AdvanceMAME Scale2x algorithm found on:
         * http://scale2x.sourceforge.net/
         *
         * It is an incredibly simple and powerful image doubling routine that does
         * an astonishing job of doubling game graphic data while interpolating out
         * the jaggies.
         *
         * Derived from the (public domain) SDL version of the library by Pete
         * Shinners.
         */

        // Assume that both src and dst are 4 BPP (B_RGBA32)
        for (int32 y = 0; y < srcHeight; ++y) {
                for (int32 x = 0; x < srcWidth; ++x) {
                        uint32 b = *(uint32*)(srcBits + (MAX(0, y - 1) * srcBPR)
                                + (4 * x));
                        uint32 d = *(uint32*)(srcBits + (y * srcBPR)
                                + (4 * MAX(0, x - 1)));
                        uint32 e = *(uint32*)(srcBits + (y * srcBPR)
                                + (4 * x));
                        uint32 f = *(uint32*)(srcBits + (y * srcBPR)
                                + (4 * MIN(srcWidth - 1, x + 1)));
                        uint32 h = *(uint32*)(srcBits + (MIN(srcHeight - 1, y + 1)
                                * srcBPR) + (4 * x));

                        uint32 e0 = d == b && b != f && d != h ? d : e;
                        uint32 e1 = b == f && b != d && f != h ? f : e;
                        uint32 e2 = d == h && d != b && h != f ? d : e;
                        uint32 e3 = h == f && d != h && b != f ? f : e;

                        *(uint32*)(dstBits + y * 2 * dstBPR + x * 2 * 4) = e0;
                        *(uint32*)(dstBits + y * 2 * dstBPR + (x * 2 + 1) * 4) = e1;
                        *(uint32*)(dstBits + (y * 2 + 1) * dstBPR + x * 2 * 4) = e2;
                        *(uint32*)(dstBits + (y * 2 + 1) * dstBPR + (x * 2 + 1) * 4) = e3;
                }
        }
}


static void
scale3x(const uint8* srcBits, uint8* dstBits, int32 srcWidth, int32 srcHeight,
        int32 srcBPR, int32 dstBPR)
{
        /*
         * This implements the AdvanceMAME Scale3x algorithm found on:
         * http://scale2x.sourceforge.net/
         *
         * It is an incredibly simple and powerful image tripling routine that does
         * an astonishing job of tripling game graphic data while interpolating out
         * the jaggies.
         *
         * Derived from the (public domain) SDL version of the library by Pete
         * Shinners.
         */

        // Assume that both src and dst are 4 BPP (B_RGBA32)
        for (int32 y = 0; y < srcHeight; ++y) {
                for (int32 x = 0; x < srcWidth; ++x) {
                        uint32 a = *(uint32*)(srcBits + (MAX(0, y - 1) * srcBPR)
                                + (4 * MAX(0, x - 1)));
                        uint32 b = *(uint32*)(srcBits + (MAX(0, y - 1) * srcBPR)
                                + (4 * x));
                        uint32 c = *(uint32*)(srcBits + (MAX(0, y - 1) * srcBPR)
                                + (4 * MIN(srcWidth - 1, x + 1)));
                        uint32 d = *(uint32*)(srcBits + (y * srcBPR)
                                + (4 * MAX(0, x - 1)));
                        uint32 e = *(uint32*)(srcBits + (y * srcBPR)
                                + (4 * x));
                        uint32 f = *(uint32*)(srcBits + (y * srcBPR)
                                + (4 * MIN(srcWidth - 1,x + 1)));
                        uint32 g = *(uint32*)(srcBits + (MIN(srcHeight - 1, y + 1)
                                * srcBPR) + (4 * MAX(0, x - 1)));
                        uint32 h = *(uint32*)(srcBits + (MIN(srcHeight - 1, y + 1)
                                * srcBPR) + (4 * x));
                        uint32 i = *(uint32*)(srcBits + (MIN(srcHeight - 1, y + 1)
                                * srcBPR) + (4 * MIN(srcWidth - 1, x + 1)));

                        uint32 e0 = d == b && b != f && d != h ? d : e;
                        uint32 e1 = (d == b && b != f && d != h && e != c)
                                || (b == f && b != d && f != h && e != a) ? b : e;
                        uint32 e2 = b == f && b != d && f != h ? f : e;
                        uint32 e3 = (d == b && b != f && d != h && e != g)
                                || (d == b && b != f && d != h && e != a) ? d : e;
                        uint32 e4 = e;
                        uint32 e5 = (b == f && b != d && f != h && e != i)
                                || (h == f && d != h && b != f && e != c) ? f : e;
                        uint32 e6 = d == h && d != b && h != f ? d : e;
                        uint32 e7 = (d == h && d != b && h != f && e != i)
                                || (h == f && d != h && b != f && e != g) ? h : e;
                        uint32 e8 = h == f && d != h && b != f ? f : e;

                        *(uint32*)(dstBits + y * 3 * dstBPR + x * 3 * 4) = e0;
                        *(uint32*)(dstBits + y * 3 * dstBPR + (x * 3 + 1) * 4) = e1;
                        *(uint32*)(dstBits + y * 3 * dstBPR + (x * 3 + 2) * 4) = e2;
                        *(uint32*)(dstBits + (y * 3 + 1) * dstBPR + x * 3 * 4) = e3;
                        *(uint32*)(dstBits + (y * 3 + 1) * dstBPR + (x * 3 + 1) * 4) = e4;
                        *(uint32*)(dstBits + (y * 3 + 1) * dstBPR + (x * 3 + 2) * 4) = e5;
                        *(uint32*)(dstBits + (y * 3 + 2) * dstBPR + x * 3 * 4) = e6;
                        *(uint32*)(dstBits + (y * 3 + 2) * dstBPR + (x * 3 + 1) * 4) = e7;
                        *(uint32*)(dstBits + (y * 3 + 2) * dstBPR + (x * 3 + 2) * 4) = e8;
                }
        }
}


static void
scale4x(const uint8* srcBits, uint8* dstBits, int32 srcWidth, int32 srcHeight,
        int32 srcBPR, int32 dstBPR)
{
        // scale4x is just scale2x twice
        BRect rect = BRect(0, 0, srcWidth * 2 - 1, srcHeight * 2 - 1);
        BBitmap* tmp = new BBitmap(rect, B_BITMAP_NO_SERVER_LINK, B_RGBA32);
        uint8* tmpBits = (uint8*)tmp->Bits();
        int32 tmpBPR = tmp->BytesPerRow();

        scale2x(srcBits, tmpBits, srcWidth, srcHeight, srcBPR, tmpBPR);
        scale2x(tmpBits, dstBits, srcWidth * 2, srcHeight * 2, tmpBPR, dstBPR);

        delete tmp;
}


//      #pragma mark - GetIcon()


status_t
BIconUtils::GetIcon(BNode* node, const char* vectorIconAttrName,
        const char* smallIconAttrName, const char* largeIconAttrName,
        icon_size which, BBitmap* icon)
{
        if (node == NULL || icon == NULL)
                return B_BAD_VALUE;

        status_t result = node->InitCheck();
        if (result != B_OK)
                return result;

        result = icon->InitCheck();
        if (result != B_OK)
                return result;

        switch (icon->ColorSpace()) {
                case B_RGBA32:
                case B_RGB32:
                        // prefer vector icon
                        result = GetVectorIcon(node, vectorIconAttrName, icon);
                        if (result != B_OK) {
                                // try to fallback to B_CMAP8 icons
                                // (converting to B_RGBA32 is handled)

                                // override size
                                if (icon->Bounds().IntegerWidth() + 1 >= B_LARGE_ICON)
                                        which = B_LARGE_ICON;
                                else
                                        which = B_MINI_ICON;

                                result = GetCMAP8Icon(node, smallIconAttrName,
                                        largeIconAttrName, which, icon);
                        }
                        break;

                case B_CMAP8:
                        // prefer old B_CMAP8 icons
                        result = GetCMAP8Icon(node, smallIconAttrName, largeIconAttrName,
                                which, icon);
                        if (result != B_OK) {
                                // try to fallback to vector icon
                                BBitmap temp(icon->Bounds(), B_BITMAP_NO_SERVER_LINK,
                                        B_RGBA32);
                                result = temp.InitCheck();
                                if (result != B_OK)
                                        break;

                                result = GetVectorIcon(node, vectorIconAttrName, &temp);
                                if (result != B_OK)
                                        break;

                                uint32 width = temp.Bounds().IntegerWidth() + 1;
                                uint32 height = temp.Bounds().IntegerHeight() + 1;
                                uint32 bytesPerRow = temp.BytesPerRow();
                                result = ConvertToCMAP8((uint8*)temp.Bits(), width, height,
                                        bytesPerRow, icon);
                        }
                        break;

                default:
                        printf("BIconUtils::GetIcon() - unsupported colorspace\n");
                        result = B_ERROR;
                        break;
        }

        return result;
}


//      #pragma mark - GetVectorIcon()


status_t
BIconUtils::GetVectorIcon(BNode* node, const char* attrName, BBitmap* icon)
{
        if (node == NULL || attrName == NULL || *attrName == '\0' || icon == NULL)
                return B_BAD_VALUE;

        status_t result = node->InitCheck();
        if (result != B_OK)
                return result;

        result = icon->InitCheck();
        if (result != B_OK)
                return result;

#if TIME_VECTOR_ICONS
        bigtime_t startTime = system_time();
#endif

        // get the attribute info and check type and size of the attr contents
        attr_info attrInfo;
        result = node->GetAttrInfo(attrName, &attrInfo);
        if (result != B_OK)
                return result;

        type_code attrType = B_VECTOR_ICON_TYPE;

        if (attrInfo.type != attrType)
                return B_BAD_TYPE;

        // chicken out on unrealisticly large attributes
        if (attrInfo.size > 512 * 1024)
                return B_BAD_VALUE;

        uint8* buffer = new(std::nothrow) uint8[attrInfo.size];
        if (buffer == NULL)
                return B_NO_MEMORY;

        ArrayDeleter<uint8> deleter(buffer);

        ssize_t bytesRead = node->ReadAttr(attrName, attrType, 0, buffer,
                attrInfo.size);
        if (bytesRead != attrInfo.size)
                return B_ERROR;

#if TIME_VECTOR_ICONS
        bigtime_t importTime = system_time();
#endif

        result = GetVectorIcon(buffer, attrInfo.size, icon);
        if (result != B_OK)
                return result;

#if TIME_VECTOR_ICONS
        bigtime_t finishTime = system_time();
        printf("read: %lld, import: %lld\n", importTime - startTime,
                finishTime - importTime);
#endif

        return B_OK;
}


status_t
BIconUtils::GetVectorIcon(const uint8* buffer, size_t size, BBitmap* icon)
{
        if (buffer == NULL || size <= 0 || icon == NULL)
                return B_BAD_VALUE;

        status_t result = icon->InitCheck();
        if (result != B_OK)
                return result;

        BBitmap* temp = icon;
        ObjectDeleter<BBitmap> deleter;

        if (icon->ColorSpace() != B_RGBA32 && icon->ColorSpace() != B_RGB32) {
                temp = new(std::nothrow) BBitmap(icon->Bounds(),
                        B_BITMAP_NO_SERVER_LINK, B_RGBA32);
                deleter.SetTo(temp);
                if (temp == NULL || temp->InitCheck() != B_OK)
                        return B_NO_MEMORY;
        }

        Icon vector;
        result = vector.InitCheck();
        if (result != B_OK)
                return result;

        FlatIconImporter importer;
        result = importer.Import(&vector, const_cast<uint8*>(buffer), size);
        if (result != B_OK) {
                // try the message based format used by Icon-O-Matic
                MessageImporter messageImporter;
                BMemoryIO memoryIO(const_cast<uint8*>(buffer), size);
                result = messageImporter.Import(&vector, &memoryIO);
                if (result != B_OK)
                        return result;
        }

        IconRenderer renderer(temp);
        renderer.SetIcon(&vector);
        renderer.SetScale((temp->Bounds().Width() + 1.0) / 64.0);
        renderer.Render();

        if (temp != icon) {
                uint8* src = (uint8*)temp->Bits();
                uint32 width = temp->Bounds().IntegerWidth() + 1;
                uint32 height = temp->Bounds().IntegerHeight() + 1;
                uint32 srcBPR = temp->BytesPerRow();
                result = ConvertToCMAP8(src, width, height, srcBPR, icon);
        }

        // TODO: would be nice to get rid of this
        // (B_RGBA32_PREMULTIPLIED or better yet, new blending_mode)
        // NOTE: probably not necessary only because
        // transparent colors are "black" in all existing icons
        // lighter transparent colors should be too dark if
        // app_server uses correct blending
        //renderer.Demultiply();

        return result;
}


//      #pragma mark - GetCMAP8Icon()


status_t
BIconUtils::GetCMAP8Icon(BNode* node, const char* smallIconAttrName,
        const char* largeIconAttrName, icon_size which, BBitmap* icon)
{
        // NOTE: this might be changed if other icon
        // sizes are supported in B_CMAP8 attributes,
        // but this is currently not the case, so we
        // relax the requirement to pass an icon
        // of just the right size
        if (which < B_LARGE_ICON)
                which = B_MINI_ICON;
        else
                which = B_LARGE_ICON;

        // check parameters and initialization
        if (node == NULL || icon == NULL
                || (which == B_MINI_ICON
                        && (smallIconAttrName == NULL || *smallIconAttrName == '\0'))
                || (which == B_LARGE_ICON
                        && (largeIconAttrName == NULL || *largeIconAttrName == '\0'))) {
                return B_BAD_VALUE;
        }

        status_t result;
        result = node->InitCheck();
        if (result != B_OK)
                return result;

        result = icon->InitCheck();
        if (result != B_OK)
                return result;

        // set some icon size related variables
        const char* attribute = NULL;
        BRect bounds;
        uint32 attrType = 0;
        off_t attrSize = 0;
        switch (which) {
                case B_MINI_ICON:
                        attribute = smallIconAttrName;
                        bounds.Set(0, 0, B_MINI_ICON - 1, B_MINI_ICON - 1);
                        attrType = B_MINI_ICON_TYPE;
                        attrSize = B_MINI_ICON * B_MINI_ICON;
                        break;

                case B_LARGE_ICON:
                        attribute = largeIconAttrName;
                        bounds.Set(0, 0, B_LARGE_ICON - 1, B_LARGE_ICON - 1);
                        attrType = B_LARGE_ICON_TYPE;
                        attrSize = B_LARGE_ICON * B_LARGE_ICON;
                        break;

                default:
                        // can not happen, see above
                        result = B_BAD_VALUE;
                        break;
        }

        // get the attribute info and check type and size of the attr contents
        attr_info attrInfo;
        if (result == B_OK)
                result = node->GetAttrInfo(attribute, &attrInfo);

        if (result == B_OK && attrInfo.type != attrType)
                result = B_BAD_TYPE;

        if (result == B_OK && attrInfo.size != attrSize)
                result = B_BAD_DATA;

        // check parameters
        // currently, scaling B_CMAP8 icons is not supported
        if (icon->ColorSpace() == B_CMAP8 && icon->Bounds() != bounds)
                return B_BAD_VALUE;

        // read the attribute
        if (result == B_OK) {
                bool useBuffer = (icon->ColorSpace() != B_CMAP8
                        || icon->Bounds() != bounds);
                uint8* buffer = NULL;
                ssize_t bytesRead;
                if (useBuffer) {
                        // other color space or bitmap size than stored in attribute
                        buffer = new(std::nothrow) uint8[attrSize];
                        if (buffer == NULL)
                                bytesRead = result = B_NO_MEMORY;
                        else {
                                bytesRead = node->ReadAttr(attribute, attrType, 0, buffer,
                                        attrSize);
                        }
                } else {
                        bytesRead = node->ReadAttr(attribute, attrType, 0, icon->Bits(),
                                attrSize);
                }

                if (result == B_OK) {
                        if (bytesRead < 0)
                                result = (status_t)bytesRead;
                        else if (bytesRead != (ssize_t)attrSize)
                                result = B_ERROR;
                }

                if (useBuffer) {
                        // other color space than stored in attribute
                        if (result == B_OK) {
                                result = ConvertFromCMAP8(buffer, (uint32)which, (uint32)which,
                                        (uint32)which, icon);
                        }
                        delete[] buffer;
                }
        }

        return result;
}


status_t
BIconUtils::GetSystemIcon(const char* iconName, BBitmap* icon)
{
        static BResources resources;
        static bool resourcesAreLoaded = false;

        if (!resourcesAreLoaded) {
                BPath path;
                status_t status = find_directory(B_SYSTEM_LIB_DIRECTORY, &path);
                if (status != B_OK) {
                        return status;
                }

                path.Append("libbe.so");
                BFile file;
                status = file.SetTo(path.Path(), B_READ_ONLY);
                if (status != B_OK) {
                        return status;
                }

                status = resources.SetTo(&file);
                if (status != B_OK) {
                        return status;
                }

                resourcesAreLoaded = true;
        }

        // Check the icon bitmap
        if (icon == NULL || icon->InitCheck() < B_OK) {
                return B_BAD_DATA;
        }

        // Load the raw icon data
        size_t size = 0;
        const uint8* rawIcon;

        // Try to load vector icon
        rawIcon = (const uint8*)resources.LoadResource(B_VECTOR_ICON_TYPE,
                iconName, &size);
        if (rawIcon != NULL
                && BIconUtils::GetVectorIcon(rawIcon, size, icon) == B_OK) {
                return B_OK;
        }

        // Fall back to bitmap icon
        rawIcon = (const uint8*)resources.LoadResource(B_LARGE_ICON_TYPE,
                iconName, &size);
        if (rawIcon == NULL) {
                delete icon;
                return B_ENTRY_NOT_FOUND;
        }

        // Handle color space conversion
        if (icon->ColorSpace() != B_CMAP8) {
                BIconUtils::ConvertFromCMAP8(rawIcon, B_LARGE_ICON, B_LARGE_ICON,
                        B_LARGE_ICON, icon);
        }

        return B_OK;
}


//      #pragma mark - ConvertFromCMAP8() and ConvertToCMAP8()


status_t
BIconUtils::ConvertFromCMAP8(BBitmap* source, BBitmap* destination)
{
        if (source == NULL || source->ColorSpace() != B_CMAP8)
                return B_BAD_VALUE;

        status_t result = source->InitCheck();
        if (result != B_OK)
                return result;

        result = destination->InitCheck();
        if (result != B_OK)
                return result;

        uint8* src = (uint8*)source->Bits();
        uint32 srcBPR = source->BytesPerRow();
        uint32 width = source->Bounds().IntegerWidth() + 1;
        uint32 height = source->Bounds().IntegerHeight() + 1;

        return ConvertFromCMAP8(src, width, height, srcBPR, destination);
}


status_t
BIconUtils::ConvertToCMAP8(BBitmap* source, BBitmap* destination)
{
        if (source == NULL || source->ColorSpace() != B_RGBA32
                || destination->ColorSpace() != B_CMAP8) {
                return B_BAD_VALUE;
        }

        status_t result = source->InitCheck();
        if (result != B_OK)
                return result;

        result = destination->InitCheck();
        if (result != B_OK)
                return result;

        uint8* src = (uint8*)source->Bits();
        uint32 srcBPR = source->BytesPerRow();
        uint32 width = source->Bounds().IntegerWidth() + 1;
        uint32 height = source->Bounds().IntegerHeight() + 1;

        return ConvertToCMAP8(src, width, height, srcBPR, destination);
}


status_t
BIconUtils::ConvertFromCMAP8(const uint8* src, uint32 width, uint32 height,
        uint32 srcBPR, BBitmap* icon)
{
        if (src == NULL || icon == NULL || srcBPR == 0)
                return B_BAD_VALUE;

        status_t result = icon->InitCheck();
        if (result != B_OK)
                return result;

        if (icon->ColorSpace() != B_RGBA32 && icon->ColorSpace() != B_RGB32) {
                // TODO: support other color spaces
                return B_BAD_VALUE;
        }

        uint32 dstWidth = icon->Bounds().IntegerWidth() + 1;
        uint32 dstHeight = icon->Bounds().IntegerHeight() + 1;

        uint8* dst = (uint8*)icon->Bits();
        uint32 dstBPR = icon->BytesPerRow();

        // check for downscaling or integer multiple scaling
        if (dstWidth < width || dstHeight < height
                || (dstWidth == 2 * width && dstHeight == 2 * height)
                || (dstWidth == 3 * width && dstHeight == 3 * height)
                || (dstWidth == 4 * width && dstHeight == 4 * height)) {
                BRect rect = BRect(0, 0, width - 1, height - 1);
                BBitmap* converted = new(std::nothrow) BBitmap(rect,
                        B_BITMAP_NO_SERVER_LINK, icon->ColorSpace());
                if (converted == NULL)
                        return B_NO_MEMORY;

                converted->ImportBits(src, height * srcBPR, srcBPR, 0, B_CMAP8);
                uint8* convertedBits = (uint8*)converted->Bits();
                int32 convertedBPR = converted->BytesPerRow();

                if (dstWidth < width || dstHeight < height)
                        scale_down(convertedBits, dst, width, height, dstWidth, dstHeight);
                else if (dstWidth == 2 * width && dstHeight == 2 * height)
                        scale2x(convertedBits, dst, width, height, convertedBPR, dstBPR);
                else if (dstWidth == 3 * width && dstHeight == 3 * height)
                        scale3x(convertedBits, dst, width, height, convertedBPR, dstBPR);
                else if (dstWidth == 4 * width && dstHeight == 4 * height)
                        scale4x(convertedBits, dst, width, height, convertedBPR, dstBPR);

                delete converted;
                return B_OK;
        }

        const rgb_color* colorMap = system_colors()->color_list;
        if (colorMap == NULL)
                return B_NO_INIT;

        const uint8* srcStart = src;
        uint8* dstStart = dst;

        // convert from B_CMAP8 to B_RGB(A)32 without scaling
        for (uint32 y = 0; y < height; y++) {
                uint32* d = (uint32*)dst;
                const uint8* s = src;
                for (uint32 x = 0; x < width; x++, s++, d++) {
                        const rgb_color c = colorMap[*s];
                        uint8 alpha = 0xff;
                        if (*s == B_TRANSPARENT_MAGIC_CMAP8)
                                alpha = 0;
                        *d = (alpha << 24) | (c.red << 16) | (c.green << 8) | (c.blue);
                }
                src += srcBPR;
                dst += dstBPR;
        }

        if (width == dstWidth && height == dstHeight)
                return B_OK;

        // reset src and dst back to their original locations
        src = srcStart;
        dst = dstStart;

        if (dstWidth > width && dstHeight > height
                && dstWidth < 2 * width && dstHeight < 2 * height) {
                // scale2x then downscale
                BRect rect = BRect(0, 0, width * 2 - 1, height * 2 - 1);
                BBitmap* temp = new(std::nothrow) BBitmap(rect,
                        B_BITMAP_NO_SERVER_LINK, icon->ColorSpace());
                if (temp == NULL)
                        return B_NO_MEMORY;

                uint8* tempBits = (uint8*)temp->Bits();
                uint32 tempBPR = temp->BytesPerRow();
                scale2x(dst, tempBits, width, height, dstBPR, tempBPR);
                scale_down(tempBits, dst, width * 2, height * 2, dstWidth, dstHeight);
                delete temp;
        } else if (dstWidth > 2 * width && dstHeight > 2 * height
                && dstWidth < 3 * width && dstHeight < 3 * height) {
                // scale3x then downscale
                BRect rect = BRect(0, 0, width * 3 - 1, height * 3 - 1);
                BBitmap* temp = new BBitmap(rect, B_BITMAP_NO_SERVER_LINK,
                        icon->ColorSpace());
                if (temp == NULL)
                        return B_NO_MEMORY;

                uint8* tempBits = (uint8*)temp->Bits();
                uint32 tempBPR = temp->BytesPerRow();
                scale3x(dst, tempBits, width, height, dstBPR, tempBPR);
                scale_down(tempBits, dst, width * 3, height * 3, dstWidth, dstHeight);
                delete temp;
        } else if (dstWidth > 3 * width && dstHeight > 3 * height
                && dstWidth < 4 * width && dstHeight < 4 * height) {
                // scale4x then downscale
                BRect rect = BRect(0, 0, width * 4 - 1, height * 4 - 1);
                BBitmap* temp = new BBitmap(rect, B_BITMAP_NO_SERVER_LINK,
                        icon->ColorSpace());
                if (temp == NULL)
                        return B_NO_MEMORY;

                uint8* tempBits = (uint8*)temp->Bits();
                uint32 tempBPR = temp->BytesPerRow();
                scale4x(dst, tempBits, width, height, dstBPR, tempBPR);
                scale_down(tempBits, dst, width * 3, height * 3, dstWidth, dstHeight);
                delete temp;
        } else if (dstWidth > 4 * width && dstHeight > 4 * height) {
                // scale4x then bilinear
                BRect rect = BRect(0, 0, width * 4 - 1, height * 4 - 1);
                BBitmap* temp = new BBitmap(rect, B_BITMAP_NO_SERVER_LINK,
                        icon->ColorSpace());
                if (temp == NULL)
                        return B_NO_MEMORY;

                uint8* tempBits = (uint8*)temp->Bits();
                uint32 tempBPR = temp->BytesPerRow();
                scale4x(dst, tempBits, width, height, dstBPR, tempBPR);
                icon->ImportBits(tempBits, height * tempBPR, tempBPR, 0,
                        temp->ColorSpace());
                scale_bilinear(dst, width, height, dstWidth, dstHeight, dstBPR);
                delete temp;
        } else {
                // fall back to bilinear scaling
                scale_bilinear(dst, width, height, dstWidth, dstHeight, dstBPR);
        }

        return B_OK;
}


status_t
BIconUtils::ConvertToCMAP8(const uint8* src, uint32 width, uint32 height,
        uint32 srcBPR, BBitmap* icon)
{
        if (src == NULL || icon == NULL || srcBPR == 0)
                return B_BAD_VALUE;

        status_t result = icon->InitCheck();
        if (result != B_OK)
                return result;

        if (icon->ColorSpace() != B_CMAP8)
                return B_BAD_VALUE;

        uint32 dstWidth = icon->Bounds().IntegerWidth() + 1;
        uint32 dstHeight = icon->Bounds().IntegerHeight() + 1;

        if (dstWidth < width || dstHeight < height) {
                // TODO: down scaling
                return B_ERROR;
        } else if (dstWidth > width || dstHeight > height) {
                // TODO: up scaling
                // (currently copies bitmap into icon at left-top)
                memset(icon->Bits(), 255, icon->BitsLength());
        }

//#if __HAIKU__
//      return icon->ImportBits(src, height * srcBPR, srcBPR, 0, B_RGBA32);
//#else
        uint8* dst = (uint8*)icon->Bits();
        uint32 dstBPR = icon->BytesPerRow();

        const color_map* colorMap = system_colors();
        if (colorMap == NULL)
                return B_NO_INIT;

        uint16 index;

        for (uint32 y = 0; y < height; y++) {
                uint8* d = dst;
                const uint8* s = src;
                for (uint32 x = 0; x < width; x++) {
                        if (s[3] < 128) {
                                *d = B_TRANSPARENT_MAGIC_CMAP8;
                        } else {
                                index = ((s[2] & 0xf8) << 7) | ((s[1] & 0xf8) << 2)
                                                | (s[0] >> 3);
                                *d = colorMap->index_map[index];
                        }
                        s += 4;
                        d += 1;
                }
                src += srcBPR;
                dst += dstBPR;
        }

        return B_OK;
//#endif // __HAIKU__
}


//      #pragma mark - Forbidden


BIconUtils::BIconUtils() {}
BIconUtils::~BIconUtils() {}
BIconUtils::BIconUtils(const BIconUtils&) {}
BIconUtils& BIconUtils::operator=(const BIconUtils&) { return *this; }