/*
 * Copyright 2014 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#include "SkTextureCompressor.h"

#include "SkBitmap.h"
#include "SkData.h"
#include "SkEndian.h"

////////////////////////////////////////////////////////////////////////////////
//
// Utility Functions
//
////////////////////////////////////////////////////////////////////////////////

// Absolute difference between two values. More correct than SkTAbs(a - b)
// because it works on unsigned values.
template <typename T> inline T abs_diff(const T &a, const T &b) {
    return (a > b) ? (a - b) : (b - a);
}

////////////////////////////////////////////////////////////////////////////////
//
// LATC compressor
//
////////////////////////////////////////////////////////////////////////////////

// Return the squared minimum error cost of approximating 'pixel' using the
// provided palette. Return this in the middle 16 bits of the integer. Return
// the best index in the palette for this pixel in the bottom 8 bits.
static uint32_t compute_error(uint8_t pixel, uint8_t palette[8]) {
    int minIndex = 0;
    uint8_t error = abs_diff(palette[0], pixel);
    for (int i = 1; i < 8; ++i) {
        uint8_t diff = abs_diff(palette[i], pixel);
        if (diff < error) {
            minIndex = i;
            error = diff;
        }
    }
    uint16_t errSq = static_cast<uint16_t>(error) * static_cast<uint16_t>(error);
    SkASSERT(minIndex >= 0 && minIndex < 8);
    return (static_cast<uint32_t>(errSq) << 8) | static_cast<uint32_t>(minIndex);
}

// Compress LATC block. Each 4x4 block of pixels is decompressed by LATC from two
// values LUM0 and LUM1, and an index into the generated palette. LATC constructs
// a palette of eight colors from LUM0 and LUM1 using the algorithm:
//
// LUM0,              if lum0 > lum1 and code(x,y) == 0
// LUM1,              if lum0 > lum1 and code(x,y) == 1
// (6*LUM0+  LUM1)/7, if lum0 > lum1 and code(x,y) == 2
// (5*LUM0+2*LUM1)/7, if lum0 > lum1 and code(x,y) == 3
// (4*LUM0+3*LUM1)/7, if lum0 > lum1 and code(x,y) == 4
// (3*LUM0+4*LUM1)/7, if lum0 > lum1 and code(x,y) == 5
// (2*LUM0+5*LUM1)/7, if lum0 > lum1 and code(x,y) == 6
// (  LUM0+6*LUM1)/7, if lum0 > lum1 and code(x,y) == 7
//
// LUM0,              if lum0 <= lum1 and code(x,y) == 0
// LUM1,              if lum0 <= lum1 and code(x,y) == 1
// (4*LUM0+  LUM1)/5, if lum0 <= lum1 and code(x,y) == 2
// (3*LUM0+2*LUM1)/5, if lum0 <= lum1 and code(x,y) == 3
// (2*LUM0+3*LUM1)/5, if lum0 <= lum1 and code(x,y) == 4
// (  LUM0+4*LUM1)/5, if lum0 <= lum1 and code(x,y) == 5
// 0,                 if lum0 <= lum1 and code(x,y) == 6
// 255,               if lum0 <= lum1 and code(x,y) == 7
//
// We compute the LATC palette using the following simple algorithm:
// 1. Choose the minimum and maximum values in the block as LUM0 and LUM1
// 2. Figure out which of the two possible palettes is better.

static uint64_t compress_latc_block(uint8_t block[16]) {
    // Just do a simple min/max but choose which of the
    // two palettes is better
    uint8_t maxVal = 0;
    uint8_t minVal = 255;
    for (int i = 0; i < 16; ++i) {
        maxVal = SkMax32(maxVal, block[i]);
        minVal = SkMin32(minVal, block[i]);
    }

    // Generate palettes
    uint8_t palettes[2][8];

    // Straight linear ramp
    palettes[0][0] = maxVal;
    palettes[0][1] = minVal;
    for (int i = 1; i < 7; ++i) {
        palettes[0][i+1] = ((7-i)*maxVal + i*minVal) / 7;
    }

    // Smaller linear ramp with min and max byte values at the end.
    palettes[1][0] = minVal;
    palettes[1][1] = maxVal;
    for (int i = 1; i < 5; ++i) {
        palettes[1][i+1] = ((5-i)*maxVal + i*minVal) / 5;
    }
    palettes[1][6] = 0;
    palettes[1][7] = 255;

    // Figure out which of the two is better:
    //  -  accumError holds the accumulated error for each pixel from
    //     the associated palette
    //  -  indices holds the best indices for each palette in the
    //     bottom 48 (16*3) bits.
    uint32_t accumError[2] = { 0, 0 };
    uint64_t indices[2] = { 0, 0 };
    for (int i = 15; i >= 0; --i) {
        // For each palette:
        // 1. Retreive the result of this pixel
        // 2. Store the error in accumError
        // 3. Store the minimum palette index in indices.
        for (int p = 0; p < 2; ++p) {
            uint32_t result = compute_error(block[i], palettes[p]);
            accumError[p] += (result >> 8);
            indices[p] <<= 3;
            indices[p] |= result & 7;
        }
    }

    SkASSERT(indices[0] < (static_cast<uint64_t>(1) << 48));
    SkASSERT(indices[1] < (static_cast<uint64_t>(1) << 48));

    uint8_t paletteIdx = (accumError[0] > accumError[1]) ? 0 : 1;

    // Assemble the compressed block.
    uint64_t result = 0;

    // Jam the first two palette entries into the bottom 16 bits of
    // a 64 bit integer. Based on the palette that we chose, one will
    // be larger than the other and it will select the proper palette.
    result |= static_cast<uint64_t>(palettes[paletteIdx][0]);
    result |= static_cast<uint64_t>(palettes[paletteIdx][1]) << 8;

    // Jam the indices into the top 48 bits.
    result |= indices[paletteIdx] << 16;

    // We assume everything is little endian, if it's not then make it so.
    return SkEndian_SwapLE64(result);
}

static SkData *compress_a8_to_latc(const SkBitmap &bm) {
    // LATC compressed texels down into square 4x4 blocks
    static const int kLATCBlockSize = 4;

    // Make sure that our data is well-formed enough to be
    // considered for LATC compression
    if (bm.width() == 0 || bm.height() == 0 ||
        (bm.width() % kLATCBlockSize) != 0 ||
        (bm.height() % kLATCBlockSize) != 0 ||
        (bm.colorType() != kAlpha_8_SkColorType)) {
        return NULL;
    }

    // The LATC format is 64 bits per 4x4 block.
    static const int kLATCEncodedBlockSize = 8;

    int blocksX = bm.width() / kLATCBlockSize;
    int blocksY = bm.height() / kLATCBlockSize;

    int compressedDataSize = blocksX * blocksY * kLATCEncodedBlockSize;
    uint64_t* dst = reinterpret_cast<uint64_t*>(sk_malloc_throw(compressedDataSize));

    uint8_t block[16];
    const uint8_t* row = reinterpret_cast<const uint8_t*>(bm.getPixels());
    uint64_t* encPtr = dst;
    for (int y = 0; y < blocksY; ++y) {
        for (int x = 0; x < blocksX; ++x) {
            memcpy(block, row + (kLATCBlockSize * x), 4);
            memcpy(block + 4, row + bm.rowBytes() + (kLATCBlockSize * x), 4);
            memcpy(block + 8, row + 2*bm.rowBytes() + (kLATCBlockSize * x), 4);
            memcpy(block + 12, row + 3*bm.rowBytes() + (kLATCBlockSize * x), 4);

            *encPtr = compress_latc_block(block);
            ++encPtr;
        }
        row += kLATCBlockSize * bm.rowBytes();
    }

    return SkData::NewFromMalloc(dst, compressedDataSize);
}

////////////////////////////////////////////////////////////////////////////////

namespace SkTextureCompressor {

typedef SkData *(*CompressBitmapProc)(const SkBitmap &bitmap);

SkData *CompressBitmapToFormat(const SkBitmap &bitmap, Format format) {
    SkAutoLockPixels alp(bitmap);

    CompressBitmapProc kProcMap[kLastEnum_SkColorType + 1][kFormatCnt];
    memset(kProcMap, 0, sizeof(kProcMap));

    // Map available bitmap configs to compression functions
    kProcMap[kAlpha_8_SkColorType][kLATC_Format] = compress_a8_to_latc;

    CompressBitmapProc proc = kProcMap[bitmap.colorType()][format];
    if (NULL != proc) {
        return proc(bitmap);
    }

    return NULL;
}

}  // namespace SkTextureCompressor