/*
 * Copyright 2006, Haiku. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Stephan Aßmus <superstippi@gmx.de>
 */

#include <malloc.h>
#include <stdio.h>
#include <string.h>
#include <zlib.h>

#include <Bitmap.h>
#include <Message.h>

enum {
        COMPRESSION_NONE = 0,
        COMPRESSION_ZLIB = 2,
};

// compress_bitmap_zlib
bool
compress_bitmap_zlib(const BBitmap* bitmap, void** buffer, unsigned* size)
{
        bool result = false;
        if (bitmap) {
                Bytef* src = (Bytef*)bitmap->Bits();
                uLong srcLength = bitmap->BitsLength();
                *size = (unsigned)ceilf(srcLength * 1.01) + 12;
                *buffer = malloc(*size);
                if (*buffer) {
                        int ret = compress2((Bytef*)*buffer,
                                                                (uLongf*)size,
                                                                src,
                                                                srcLength,
                                                                3);
                        if (ret == Z_OK) {
// printf("zlib compressed %ld bytes bitmap into %d bytes (%f%%)\n",
//      srcLength, *size, ((float)*size / (float)srcLength) * 100.0);
                                if ((unsigned)ceilf(srcLength * 1.01) + 12 != *size) {
                                        void* tmpBuffer = realloc(*buffer, *size);
                                        if (tmpBuffer) {
                                                *buffer = tmpBuffer;
                                                result = true;
                                        }
                                }
                        }
                        if (ret != Z_OK || !result) {
                                // error compressing
                                free(*buffer);
                                *buffer = NULL;
                                *size = 0;
                                fprintf(stderr, "zlib compression error: %d\n", ret);
                        }
                } else
                        *size = 0;
        }
        return result;
}

// decompress_bitmap_zlib
BBitmap*
decompress_bitmap_zlib(const void* buffer, unsigned int size,
                                           BRect frame, color_space format)
{
        BBitmap* bitmap = new BBitmap(frame, 0, format);
        if (bitmap->IsValid()) {
                if (buffer) {
                        Bytef* dst = (Bytef*)bitmap->Bits();
                        uLongf dstLength = bitmap->BitsLength();

                        int ret = uncompress(dst,
                                                                 &dstLength,
                                                                 (const Bytef*)buffer,
                                                                 (uLong)size);
                        if (ret != Z_OK || dstLength != (uint32)bitmap->BitsLength()) {
                                // decompression error!
                                fprintf(stderr, "decompress_bitmap_zlib() failed "
                                                                "- corrupted input buffer or file!\n");
                        }
                } else {
                        memset(bitmap->Bits(), 0, bitmap->BitsLength());
                }
        } else {
                delete bitmap;
                bitmap = NULL;
        }
        return bitmap;
}



// archive_bitmap
status_t
archive_bitmap(const BBitmap* bitmap, BMessage* into, const char* fieldName)
{
        status_t ret = B_BAD_VALUE;
        if (bitmap && bitmap->IsValid() && into) {
                void* buffer;
                unsigned size;
                if (compress_bitmap_zlib(bitmap, &buffer, &size)) {
                        ret = into->AddData(fieldName, B_RAW_TYPE, buffer, size);
                        if (ret >= B_OK)
                                ret = into->AddInt32("compression", COMPRESSION_ZLIB);
                        if (ret >= B_OK)
                                ret = into->AddRect("construction bounds", bitmap->Bounds());
                        if (ret >= B_OK)
                                ret = into->AddInt32("format", bitmap->ColorSpace());
                        free(buffer);
                }
        }
        return ret;
}

// extract_bitmap
status_t
extract_bitmap(BBitmap** bitmap, const BMessage* from, const char* fieldName)
{
        status_t ret = B_BAD_VALUE;
        if (bitmap && from) {
                *bitmap = NULL;
                // no compression (flattened BBitmap archive)
                BMessage bitmapArchive;
                if ((ret = from->FindMessage(fieldName, &bitmapArchive)) >= B_OK) {
                        *bitmap = new BBitmap(&bitmapArchive);
                }
                // compression
                if (!*bitmap) {
                        const void* compressedData = NULL;
                        ssize_t compressedSize = 0;
                        compressedData = NULL;
                        compressedSize = 0;
                        BRect bounds;
                        color_space format;
                        uint32 compression;
                        if (((ret = from->FindData(fieldName,
                                                                          B_RAW_TYPE, &compressedData,
                                                                          &compressedSize)) >= B_OK
                                  // this is for backward compatibility
                                  || (ret = from->FindData("current compressed data",
                                                                          B_RAW_TYPE, &compressedData,
                                                                          &compressedSize)) >= B_OK)
                                && (ret = from->FindRect("construction bounds",
                                                                                 &bounds)) >= B_OK) {
                        
                                // compression defaults to NONE for backward compatibility
                                if (from->FindInt32("compression", (int32*)&compression) < B_OK)
                                        compression = COMPRESSION_NONE;
                                // format defaults to B_RGBA32 for backward compatibility
                                if (from->FindInt32("format", (int32*)&format) < B_OK)
                                        format = B_RGBA32;

                                switch (compression) {
                                        case COMPRESSION_ZLIB:
                                                *bitmap = decompress_bitmap_zlib(compressedData,
                                                                                                                 compressedSize,
                                                                                                                 bounds, format);
                                                break;
                                }
                        }
                }
                if (*bitmap)
                        ret = (*bitmap)->InitCheck();
                else if (ret >= B_OK)
                        ret = B_NO_MEMORY;
                if (ret < B_OK) {
                        delete *bitmap;
                        *bitmap = NULL;
                }
        }
        return ret;
}