/*
 * Copyright 2005, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
 * Distributed under the terms of the MIT License.
 */

// ToDo: This definitely needs to be worked over for endian issues

#include "ICO.h"
#include "ICOTranslator.h"

#include <ByteOrder.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>


//#define TRACE_ICO
#ifdef TRACE_ICO
#       define TRACE(x) printf x
#else
#       define TRACE(x) ;
#endif


using namespace ICO;


static const rgba32_color kMagicTransparentColor = *(rgba32_color *)&B_TRANSPARENT_MAGIC_RGBA32;


class TempAllocator {
        public:
                TempAllocator() : fMemory(NULL) {}
                ~TempAllocator() { free(fMemory); }

                void *Allocate(size_t size) { return fMemory = malloc(size); }

        private:
                void    *fMemory;
};


bool 
ico_header::IsValid() const
{
        return reserved == 0
                && (type == kTypeIcon || type == kTypeCursor)
                && entry_count < 32;
}


void
ico_header::SwapToHost()
{
        swap_data(B_UINT16_TYPE, this, sizeof(ico_header), B_SWAP_LENDIAN_TO_HOST);
}


void
ico_header::SwapFromHost()
{
        swap_data(B_UINT16_TYPE, this, sizeof(ico_header), B_SWAP_HOST_TO_LENDIAN);
}


//      #pragma mark -


void
ico_dir_entry::SwapToHost()
{
        swap_data(B_UINT16_TYPE, &planes, sizeof(uint16) * 2, B_SWAP_LENDIAN_TO_HOST);
        swap_data(B_UINT32_TYPE, &size, sizeof(uint32) * 2, B_SWAP_LENDIAN_TO_HOST);
}


void
ico_dir_entry::SwapFromHost()
{
        swap_data(B_UINT16_TYPE, &planes, sizeof(uint16) * 2, B_SWAP_HOST_TO_LENDIAN);
        swap_data(B_UINT32_TYPE, &size, sizeof(uint32) * 2, B_SWAP_HOST_TO_LENDIAN);
}


//      #pragma mark -


bool
ico_bitmap_header::IsValid() const
{
        return size == sizeof(ico_bitmap_header) && compression == 0
                && (bits_per_pixel == 1 || bits_per_pixel == 4 || bits_per_pixel == 8
                        || bits_per_pixel == 16 || bits_per_pixel == 24 || bits_per_pixel == 32);
}


void
ico_bitmap_header::SwapToHost()
{
        swap_data(B_UINT32_TYPE, &size, sizeof(uint32) * 3, B_SWAP_LENDIAN_TO_HOST);
        swap_data(B_UINT16_TYPE, &planes, sizeof(uint16) * 2, B_SWAP_LENDIAN_TO_HOST);
        swap_data(B_UINT32_TYPE, &compression, sizeof(uint32) * 6, B_SWAP_LENDIAN_TO_HOST);
}


void
ico_bitmap_header::SwapFromHost()
{
        swap_data(B_UINT32_TYPE, &size, sizeof(uint32) * 3, B_SWAP_HOST_TO_LENDIAN);
        swap_data(B_UINT16_TYPE, &planes, sizeof(uint16) * 2, B_SWAP_HOST_TO_LENDIAN);
        swap_data(B_UINT32_TYPE, &compression, sizeof(uint32) * 6, B_SWAP_HOST_TO_LENDIAN);
}


//      #pragma mark -


static inline uint8 *
get_data_row(uint8 *data, int32 dataSize, int32 rowBytes, int32 row)
{
        return data + dataSize - (row + 1) * rowBytes;
}


static inline int32
get_bytes_per_row(int32 width, int32 bitsPerPixel)
{
        return (((bitsPerPixel * width + 7) / 8) + 3) & ~3;
}


static inline void
set_1_bit_per_pixel(uint8 *line, int32 x, int32 value)
{
        int32 mask = 1 << (7 - (x & 7));
        if (value)
                line[x / 8] |= mask;
        else
                line[x / 8] &= ~mask;
}


static inline void
set_4_bits_per_pixel(uint8 *line, int32 x, int32 value)
{
        int32 shift = x & 1 ? 0 : 4;
        int32 mask = ~0L & (0xf0 >> shift);

        line[x / 2] &= mask;
        line[x / 2] |= value << shift;
}


static inline int32
get_1_bit_per_pixel(uint8 *line, int32 x)
{
        return (line[x / 8] >> (7 - (x & 7))) & 1;
}


static inline int32
get_4_bits_per_pixel(uint8 *line, int32 x)
{
        return (line[x / 2] >> (4 * ((x + 1) & 1))) & 0xf;
}


static uint8
get_alpha_value(color_space space, uint32 value)
{
        // ToDo: support more color spaces
        if (space == B_RGBA32)
                return value >> 24;

        return 0;
}


static uint16
rgba32_color_to_16_bit_color(rgba32_color &color)
{
        return ((color.blue >> 3) << 11) | ((color.green >> 2) << 5) | (color.red >> 3);
}


static int32
find_rgba32_color(rgba32_color *palette, int32 numColors, rgba32_color &color)
{
        // ToDo: sorting and binary search?
        for (int32 i = 0; i < numColors; i++) {
                if (palette[i] == color)
                        return i;
        }

        return -1;
}


static inline rgba32_color
get_rgba32_color_from_bits(TranslatorBitmap &bitsHeader, uint8 *data, int32 x, int32 y)
{
        data += bitsHeader.rowBytes * y;

        switch (bitsHeader.colors) {
                case B_RGBA32:
                        return *(rgba32_color *)(data + 4 * x);
                case B_RGB32:
                default:
                        // stupid applications like ArtPaint use the alpha channel in B_RGB32 images...
                        rgba32_color color = *(rgba32_color *)(data + 4 * x);
                        if (color.alpha >= 128)
                                color.alpha = 255;
                        else
                                color.alpha = 0;
                        return color;
                // ToDo: support some more color spaces...
        }
}


static int32
fill_palette(TranslatorBitmap &bitsHeader, uint8 *data, rgba32_color *palette)
{
        int32 numColors = 0;

        for (int32 y = 0; y < bitsHeader.bounds.IntegerHeight() + 1; y++) {
                for (int32 x = 0; x < bitsHeader.bounds.IntegerWidth() + 1; x++) {
                        rgba32_color color = get_rgba32_color_from_bits(bitsHeader, data, x, y);

                        int32 index = find_rgba32_color(palette, numColors, color);
                        if (index == -1) {
                                // add this color if there is space left
                                if (numColors == 256)
                                        return -1;

                                color.alpha = 0;
                                        // the alpha channel is actually unused
                                palette[numColors++] = color;
                        }
                }
        }

        return numColors;
}


/**     This function is used to determine, if a true alpha channel has to
 *      be used in order to preserve all information.
 */

static bool
has_true_alpha_channel(color_space space, uint8 *data,
        int32 width, int32 height, int32 bytesPerRow)
{
        for (int32 y = 0; y < height; y++) {
                for (int32 x = 0; x < width; x++) {
                        uint8 value = get_alpha_value(space, ((uint32 *)data)[x]);
                        if (value != 0 && value != 255)
                                return true;
                }

                data += bytesPerRow;
        }

        return false;
}


static status_t
convert_data_to_bits(ico_dir_entry &entry, ico_bitmap_header &header,
        const rgba32_color *palette, BPositionIO &source,
        BPositionIO &target)
{
        uint16 bitsPerPixel = header.bits_per_pixel;

        // round row bytes to next 4 byte boundary
        int32 xorRowBytes = get_bytes_per_row(entry.width, header.bits_per_pixel);
        int32 andRowBytes = 0;
        if (bitsPerPixel != 32)
                andRowBytes = get_bytes_per_row(entry.width, 1);
        int32 outRowBytes = entry.width * 4;

        // allocate buffers
        TempAllocator xorAllocator, andAllocator, rowAllocator;

        int32 xorDataSize = xorRowBytes * entry.height;
        uint8 *xorData = (uint8 *)xorAllocator.Allocate(xorDataSize);
        if (xorData == NULL)
                return B_NO_MEMORY;

        int32 andDataSize = andRowBytes * entry.height;
        uint8 *andData = NULL;
        if (bitsPerPixel != 32) {
                andData = (uint8 *)andAllocator.Allocate(andDataSize);
                if (andData == NULL)
                        return B_NO_MEMORY;
        }

        rgba32_color *outRowData = (rgba32_color *)rowAllocator.Allocate(outRowBytes);
        if (outRowData == NULL)
                return B_NO_MEMORY;

        ssize_t bytesRead = source.Read(xorData, xorDataSize);
        if (bytesRead != xorDataSize)
                return B_BAD_DATA;

        if (bitsPerPixel != 32) {
                bytesRead = source.Read(andData, andDataSize);
                if (bytesRead != andDataSize) {
                        // reading the alpha channel failed, so we're ignoring it
                        // (but we're still able to show the image data)
                        andData = NULL;
                }
        }

        for (uint32 row = 0; row < entry.height; row++) {
                for (uint32 x = 0; x < entry.width; x++) {
                        uint8 *line = get_data_row(xorData, xorDataSize, xorRowBytes, row);

                        if (palette != NULL) {
                                uint8 index;

                                switch (bitsPerPixel) {
                                        case 1:
                                                index = get_1_bit_per_pixel(line, x);
                                                break;
                                        case 4:
                                                index = get_4_bits_per_pixel(line, x);
                                                break;
                                        case 8:
                                        default:
                                                index = line[x];
                                                break;
                                }

                                outRowData[x] = palette[index];
                        } else {
                                switch (bitsPerPixel) {
                                        case 16:
                                        {
                                                uint16 color = ((uint16 *)line)[x];
                                                outRowData[x].blue = (color >> 11) << 3;
                                                outRowData[x].green = ((color >> 5) & 0x3f) << 3;
                                                outRowData[x].red = (color & 0x1f) << 3;
                                                break;
                                        }

                                        case 24:
                                                outRowData[x].blue = line[x * 3 + 0];
                                                outRowData[x].green = line[x * 3 + 1];
                                                outRowData[x].red = line[x * 3 + 2];
                                                break;

                                        case 32:
                                                outRowData[x] = ((rgba32_color *)line)[x];
                                                break;
                                }
                        }

                        if (bitsPerPixel != 32) {
                                // set alpha channel
                                if (andData != NULL
                                        && get_1_bit_per_pixel(get_data_row(andData, andDataSize, andRowBytes, row), x))
                                        outRowData[x] = kMagicTransparentColor;
                                else
                                        outRowData[x].alpha = 255;
                        } else if (outRowData[x].alpha == 0)
                                outRowData[x] = kMagicTransparentColor;
                }

                ssize_t bytesWritten = target.Write(outRowData, outRowBytes);
                if (bytesWritten < B_OK)
                        return bytesWritten;
                if (bytesWritten != outRowBytes)
                        return B_IO_ERROR;
        }

        return B_OK;
}


static status_t
convert_bits_to_data(TranslatorBitmap &bitsHeader, uint8 *bitsData, ico_dir_entry &entry,
        ico_bitmap_header &header, rgba32_color *palette, BPositionIO &target)
{
        int32 bitsPerPixel = header.bits_per_pixel;

        // round row bytes to next 4 byte boundary
        int32 xorRowBytes = get_bytes_per_row(entry.width, bitsPerPixel);
        int32 andRowBytes = get_bytes_per_row(entry.width, 1);

        TempAllocator xorAllocator, andAllocator;

        uint8 *xorRowData = (uint8 *)xorAllocator.Allocate(xorRowBytes);
        if (xorRowData == NULL)
                return B_NO_MEMORY;

        uint8 *andRowData = (uint8 *)andAllocator.Allocate(andRowBytes);
        if (andRowData == NULL)
                return B_NO_MEMORY;

        int32 numColors = 1 << bitsPerPixel;

        // write XOR data (the actual image data)
        // (ICO data is upside down, so we're starting at the last line)

        for (uint32 row = entry.height; row-- > 0;) {
                for (uint32 x = 0; x < entry.width; x++) {
                        rgba32_color color = get_rgba32_color_from_bits(bitsHeader, bitsData, x, row);

                        if (palette != NULL) {
                                uint8 index = find_rgba32_color(palette, numColors, color);

                                switch (bitsPerPixel) {
                                        case 1:
                                                set_1_bit_per_pixel(xorRowData, x, index);
                                                break;
                                        case 4:
                                                set_4_bits_per_pixel(xorRowData, x, index);
                                                break;
                                        case 8:
                                        default:
                                                xorRowData[x] = index;
                                                break;
                                }
                        } else {
                                switch (bitsPerPixel) {
                                        default:
                                        case 16:
                                        {
                                                uint16 *data = (uint16 *)xorRowData;
                                                data[x] = rgba32_color_to_16_bit_color(color); 
                                                break;
                                        }

                                        case 24:
                                        {
                                                xorRowData[x * 3 + 0] = color.blue;
                                                xorRowData[x * 3 + 1] = color.green;
                                                xorRowData[x * 3 + 2] = color.red;
                                                break;
                                        }

                                        case 32:
                                        {
                                                rgba32_color *data = (rgba32_color *)xorRowData;
                                                data[x] = color;
                                                break;
                                        }
                                }
                        }
                }

                ssize_t bytesWritten = target.Write(xorRowData, xorRowBytes);
                if (bytesWritten < B_OK)
                        return bytesWritten;
                if (bytesWritten != xorRowBytes)
                        return B_IO_ERROR;
        }

        if (bitsPerPixel == 32) {
                // the alpha channel has already been written with the image data
                return B_OK;
        }

        // write AND data (the transparency bit)

        for (uint32 row = entry.height; row-- > 0;) {
                for (uint32 x = 0; x < entry.width; x++) {
                        rgba32_color color = get_rgba32_color_from_bits(bitsHeader, bitsData, x, row);
                        bool transparent = *(uint32 *)&color == B_TRANSPARENT_MAGIC_RGBA32 || color.alpha == 0;

                        set_1_bit_per_pixel(andRowData, x, transparent ? 1 : 0);
                }

                ssize_t bytesWritten = target.Write(andRowData, andRowBytes);
                if (bytesWritten < B_OK)
                        return bytesWritten;
                if (bytesWritten != andRowBytes)
                        return B_IO_ERROR;
        }

        return B_OK;
}


//      #pragma mark -


bool
ICO::is_valid_size(int32 size)
{
        return size == 16 || size == 32 || size == 48;
}


status_t
ICO::identify(BMessage *settings, BPositionIO &stream, uint8 &type, int32 &bitsPerPixel)
{
        // read in the header

        ico_header header;
        if (stream.Read(&header, sizeof(ico_header)) != (ssize_t)sizeof(ico_header))
                return B_BAD_VALUE;

        header.SwapToHost();

        // check header

        if (!header.IsValid())
                return B_BAD_VALUE;

        int32 iconIndex = 0;
        type = header.type;

        if (settings) {
                // Add page count to ioExtension
                settings->RemoveName(kDocumentCount);
                settings->AddInt32(kDocumentCount, header.entry_count);

                // Check if a document index has been specified 
                if (settings->FindInt32(kDocumentIndex, &iconIndex) == B_OK)
                        iconIndex--;
                else
                        iconIndex = 0;

                if (iconIndex < 0 || iconIndex >= header.entry_count)
                        return B_NO_TRANSLATOR;
        }

        TRACE(("iconIndex = %ld, count = %ld\n", iconIndex, header.entry_count));

        // read in directory entries

        for (uint32 i = 0; i < header.entry_count; i++) {
                ico_dir_entry entry;
                if (stream.Read(&entry, sizeof(ico_dir_entry)) != (ssize_t)sizeof(ico_dir_entry))
                        return B_BAD_VALUE;

                entry.SwapToHost();
                TRACE(("width: %d, height: %d, planes: %d, color_count: %d, bits_per_pixel: %d, size: %ld, offset: %ld\n",
                        entry.width, entry.height, entry.planes, entry.color_count, entry.bits_per_pixel,
                        entry.size, entry.offset));

                ico_bitmap_header bitmapHeader;
                if (stream.ReadAt(entry.offset, &bitmapHeader, sizeof(ico_bitmap_header)) != (ssize_t)sizeof(ico_bitmap_header))
                        return B_BAD_VALUE;

                bitmapHeader.SwapToHost();
                TRACE(("size: %ld, width: %ld, height: %ld, bits_per_pixel: %d, x/y per meter: %ld:%ld, compression: %ld, image_size: %ld, colors used: %ld, important colors: %ld\n",
                        bitmapHeader.size, bitmapHeader.width, bitmapHeader.height, bitmapHeader.bits_per_pixel,
                        bitmapHeader.x_pixels_per_meter, bitmapHeader.y_pixels_per_meter,
                        bitmapHeader.compression, bitmapHeader.image_size, bitmapHeader.colors_used,
                        bitmapHeader.important_colors));

                if (!bitmapHeader.IsValid())
                        return B_BAD_VALUE;

                if ((uint32)iconIndex == i)
                        bitsPerPixel = bitmapHeader.bits_per_pixel;
        }

        return B_OK;
}


/**     Converts an ICO image of any type into a B_RGBA32 B_TRANSLATOR_BITMAP.
 */

status_t
ICO::convert_ico_to_bits(BMessage *settings, BPositionIO &source, BPositionIO &target)
{
        ico_header header;
        if (source.Read(&header, sizeof(ico_header)) != (ssize_t)sizeof(ico_header))
                return B_BAD_VALUE;

        header.SwapToHost();

        // check header

        if (!header.IsValid())
                return B_BAD_VALUE;

        int32 iconIndex = 0;

        if (settings) {
                // Check if a document index has been specified 
                if (settings->FindInt32(kDocumentIndex, &iconIndex) == B_OK)
                        iconIndex--;
                else
                        iconIndex = 0;

                if (iconIndex < 0 || iconIndex >= header.entry_count)
                        return B_BAD_VALUE;
        }

        // read in selected entry

        ico_dir_entry entry;
        if (source.ReadAt(sizeof(ico_header) + sizeof(ico_dir_entry) * iconIndex,
                        &entry, sizeof(ico_dir_entry)) != (ssize_t)sizeof(ico_dir_entry))
                return B_BAD_VALUE;

        entry.SwapToHost();
        source.Seek(entry.offset, SEEK_SET);

        ico_bitmap_header bitmapHeader;
        if (source.Read(&bitmapHeader, sizeof(ico_bitmap_header)) != (ssize_t)sizeof(ico_bitmap_header))
                return B_BAD_VALUE;

        bitmapHeader.SwapToHost();

        if (!bitmapHeader.IsValid())
                return B_BAD_VALUE;

        if (bitmapHeader.compression != 0)
                return EOPNOTSUPP;

        int32 numColors = 0;
        if (bitmapHeader.bits_per_pixel <= 8)
                numColors = 1L << bitmapHeader.bits_per_pixel;

        // This is a work-around for a broken ICO file writer that publishes
        // a wrong image height in the ico_dir_entry structure
        if (entry.size != 0 && 2 * entry.width == entry.height && numColors != 0
                && sizeof(rgba32_color) * numColors + entry.width * entry.height > entry.size)
                entry.height = entry.width;

        TranslatorBitmap bitsHeader;
        bitsHeader.magic = B_TRANSLATOR_BITMAP;
        bitsHeader.bounds.left = 0;
        bitsHeader.bounds.top = 0;
        bitsHeader.bounds.right = entry.width - 1;
        bitsHeader.bounds.bottom = entry.height - 1;
        bitsHeader.bounds.Set(0, 0, entry.width - 1, entry.height - 1);
        bitsHeader.rowBytes = entry.width * 4;
        bitsHeader.colors = B_RGBA32;
        bitsHeader.dataSize = bitsHeader.rowBytes * entry.height;

        // read in palette

        rgba32_color palette[256];
        if (numColors > 0) {
                if (source.Read(palette, numColors * 4) != numColors * 4)
                        return B_BAD_VALUE;

                // clear alpha channel (it's not used in ICO color information)
                for (int32 i = 0; i < numColors; i++)
                        palette[i].alpha = 0;
        }

        // write out Be's Bitmap header
        swap_data(B_UINT32_TYPE, &bitsHeader, sizeof(TranslatorBitmap), B_SWAP_HOST_TO_BENDIAN);
        target.Write(&bitsHeader, sizeof(TranslatorBitmap));

        return convert_data_to_bits(entry, bitmapHeader, numColors > 0 ? palette : NULL, source, target);
}


status_t
ICO::convert_bits_to_ico(BMessage *settings, BPositionIO &source,
        TranslatorBitmap &bitsHeader, BPositionIO &target)
{
        int32 width = bitsHeader.bounds.IntegerWidth() + 1;
        int32 height = bitsHeader.bounds.IntegerHeight() + 1;
        if (!is_valid_size(width) || !is_valid_size(height))
                return B_BAD_VALUE;

        int32 bitsPerPixel;
        switch (bitsHeader.colors) {
                case B_RGBA32:
                        bitsPerPixel = 32;
                        break;
                case B_RGB32:
                        bitsPerPixel = 24;
                        break;
                case B_RGB16:
                        bitsPerPixel = 16;
                        break;
                case B_CMAP8:
                case B_GRAY8:
                        bitsPerPixel = 8;
                        break;
                case B_GRAY1:
                        bitsPerPixel = 1;
                        break;
                default:
                        fprintf(stderr, "unsupported color space.\n");
                        return B_BAD_VALUE;
        }

        TempAllocator dataAllocator;
        uint8 *bitsData = (uint8 *)dataAllocator.Allocate(bitsHeader.rowBytes * height);
        if (bitsData == NULL)
                return B_NO_MEMORY;
                
        ssize_t bytesRead = source.Read(bitsData, bitsHeader.rowBytes * height);
        if (bytesRead < B_OK)
                return bytesRead;

        rgba32_color palette[256];
        if (bitsPerPixel > 8) {
                // it's a non-palette mode - but does it have to be?
                if (bitsHeader.colors != B_RGBA32
                        || !has_true_alpha_channel(bitsHeader.colors, bitsData,
                                        width, height, bitsHeader.rowBytes)) {
                        memset(palette, 0, sizeof(palette));

                        // count colors
                        int32 colors = fill_palette(bitsHeader, bitsData, palette);
                        if (colors != -1) {
                                // we fit into a palette mode
                                if (colors > 16)
                                        bitsPerPixel = 8;
                                else if (colors > 2)
                                        bitsPerPixel = 4;
                                else
                                        bitsPerPixel = 1;
                        }
                }
        }
        int32 numColors = 1 << bitsPerPixel;

        ico_header header;
        header.type = B_HOST_TO_LENDIAN_INT16(1);
        header.entry_count = B_HOST_TO_LENDIAN_INT16(1);
        header.reserved = 0;
        
        ssize_t bytesWritten = target.Write(&header, sizeof(ico_header));
        if (bytesWritten < B_OK)
                return bytesWritten;

        ico_dir_entry entry;
        entry.width = width;
        entry.height = height;
        entry.planes = 1;
        entry.bits_per_pixel = bitsPerPixel;
        entry.color_count = 0;
        if (bitsPerPixel <= 8)
                entry.color_count = numColors;

        // When bits_per_pixel == 32, the data already contains the alpha channel

        int32 xorRowBytes = get_bytes_per_row(width, bitsPerPixel);
        int32 andRowBytes = 0;
        if (bitsPerPixel != 32)
                andRowBytes = get_bytes_per_row(width, 1);

        entry.size = sizeof(ico_bitmap_header) + width * (xorRowBytes + andRowBytes);
        if (bitsPerPixel <= 8)
                entry.size += numColors * sizeof(rgba32_color);
        entry.offset = sizeof(ico_header) + sizeof(ico_dir_entry);
        entry.reserved = 0;

        ico_bitmap_header bitmapHeader;
        memset(&bitmapHeader, 0, sizeof(ico_bitmap_header));
        bitmapHeader.size = sizeof(ico_bitmap_header);
        bitmapHeader.width = width;
        bitmapHeader.height = height + (bitsPerPixel == 32 ? 0 : height);
        bitmapHeader.bits_per_pixel = bitsPerPixel;
        bitmapHeader.planes = 1;
        bitmapHeader.image_size = 0;
        if (bitsPerPixel <= 8)
                bitmapHeader.colors_used = numColors;

        entry.SwapFromHost();
        bitmapHeader.SwapFromHost();

        bytesWritten = target.Write(&entry, sizeof(ico_dir_entry));
        if (bytesWritten < B_OK)
                return bytesWritten;

        bytesWritten = target.Write(&bitmapHeader, sizeof(ico_bitmap_header));
        if (bytesWritten < B_OK)
                return bytesWritten;

        // we'll need them in convert_bits_to_data()
        entry.SwapToHost();
        bitmapHeader.SwapToHost();

        if (bitsPerPixel <= 8) {
                bytesWritten = target.Write(palette, numColors * sizeof(rgba32_color));
                if (bytesWritten < B_OK)
                        return bytesWritten;
        }

        return convert_bits_to_data(bitsHeader, bitsData, entry, bitmapHeader,
                bitsPerPixel <= 8 ? palette : NULL, target);
}