#include "Resize.h"

static FREE_IMAGE_COLOR_TYPE

GetExtendedColorType(FIBITMAP *dib, BOOL *bIsGreyscale) {

}

static inline RGBQUAD *

GetRGBAPalette(FIBITMAP *dib, RGBQUAD * const buffer) {

// clone the palette

const unsigned ncolors = FreeImage_GetColorsUsed(dib);

if (ncolors == 0) {

return NULL;

}

memcpy(buffer, FreeImage_GetPalette(dib), ncolors * sizeof(RGBQUAD));

// merge the transparency table

const unsigned ntransp = MIN(ncolors, FreeImage_GetTransparencyCount(dib));

const BYTE * const tt = FreeImage_GetTransparencyTable(dib);

for (unsigned i = 0; i < ntransp; i++) {

buffer[i].rgbReserved = tt[i];

}

for (unsigned i = ntransp; i < ncolors; i++) {

buffer[i].rgbReserved = 255;

}

return buffer;

}

CWeightsTable::CWeightsTable(CGenericFilter *pFilter, unsigned uDstSize, unsigned uSrcSize) {

}

CWeightsTable::~CWeightsTable() {

for(unsigned u = 0; u < m_LineLength; u++) {

// free contributions for every pixel

free(m_WeightTable[u].Weights);

}

// free list of pixels contributions

free(m_WeightTable);

}

FIBITMAP* CResizeEngine::scale(FIBITMAP *src, unsigned dst_width, unsigned dst_height, unsigned src_left, unsigned src_top, unsigned src_width, unsigned src_height, unsigned flags) {

const FREE_IMAGE_TYPE image_type = FreeImage_GetImageType(src);

const unsigned src_bpp = FreeImage_GetBPP(src);

// determine the image's color type

BOOL bIsGreyscale = FALSE;

FREE_IMAGE_COLOR_TYPE color_type;

if (src_bpp <= 8) {

color_type = GetExtendedColorType(src, &bIsGreyscale);

} else {

color_type = FIC_RGB;

}

// determine the required bit depth of the destination image

unsigned dst_bpp;

unsigned dst_bpp_s1 = 0;

if (color_type == FIC_PALETTE && !bIsGreyscale) {

// non greyscale FIC_PALETTE images require a high-color destination

// image (24- or 32-bits depending on the image's transparent state)

dst_bpp = FreeImage_IsTransparent(src) ? 32 : 24;

} else if (src_bpp <= 8) {

// greyscale images require an 8-bit destination image

// (or a 32-bit image if the image is transparent);

// however, if flag FI_RESCALE_TRUE_COLOR is set, we will return

// a true color (24 bpp) image

if (FreeImage_IsTransparent(src)) {

dst_bpp = 32;

// additionally, for transparent images we always need a

// palette including transparency information (an RGBA palette)

// so, set color_type accordingly

color_type = FIC_PALETTE;

} else {

dst_bpp = ((flags & FI_RESCALE_TRUE_COLOR) == FI_RESCALE_TRUE_COLOR) ? 24 : 8;

// in any case, we use a fast 8-bit temporary image for the

// first filter operation (stage 1, either horizontal or

// vertical) and implicitly convert to 24 bpp (if requested

// by flag FI_RESCALE_TRUE_COLOR) during the second filter

// operation

dst_bpp_s1 = 8;

}

} else if (src_bpp == 16 && image_type == FIT_BITMAP) {

// 16-bit 555 and 565 RGB images require a high-color destination

// image (fixed to 24 bits, since 16-bit RGBs don't support

// transparency in FreeImage)

dst_bpp = 24;

} else {

// bit depth remains unchanged for all other images

dst_bpp = src_bpp;

}

// make 'stage 1' bpp a copy of the destination bpp if it

// was not explicitly set

if (dst_bpp_s1 == 0) {

dst_bpp_s1 = dst_bpp;

}

// early exit if destination size is equal to source size

if ((src_width == dst_width) && (src_height == dst_height)) {

FIBITMAP *out = src;

FIBITMAP *tmp = src;

if ((src_width != FreeImage_GetWidth(src)) || (src_height != FreeImage_GetHeight(src))) {

out = FreeImage_Copy(tmp, src_left, src_top, src_left + src_width, src_top + src_height);

tmp = out;

}

if (src_bpp != dst_bpp) {

switch (dst_bpp) {

case 8:

out = FreeImage_ConvertToGreyscale(tmp);

break;

case 24:

out = FreeImage_ConvertTo24Bits(tmp);

break;

case 32:

out = FreeImage_ConvertTo32Bits(tmp);

break;

default:

break;

}

if (tmp != src) {

FreeImage_Unload(tmp);

tmp = NULL;

}

}

return (out != src) ? out : FreeImage_Clone(src);

}

RGBQUAD pal_buffer[256];

RGBQUAD *src_pal = NULL;

// provide the source image's palette to the rescaler for

// FIC_PALETTE type images (this includes palletized greyscale

// images with an unordered palette as well as transparent images)

if (color_type == FIC_PALETTE) {

if (dst_bpp == 32) {

// a 32-bit destination image signals transparency, so

// create an RGBA palette from the source palette

src_pal = GetRGBAPalette(src, pal_buffer);

} else {

src_pal = FreeImage_GetPalette(src);

}

}

// allocate the dst image

FIBITMAP *dst = FreeImage_AllocateT(image_type, dst_width, dst_height, dst_bpp, 0, 0, 0);

if (!dst) {

return NULL;

}

if (dst_bpp == 8) {

RGBQUAD * const dst_pal = FreeImage_GetPalette(dst);

if (color_type == FIC_MINISWHITE) {

// build an inverted greyscale palette

CREATE_GREYSCALE_PALETTE_REVERSE(dst_pal, 256);

}

/*

}

// calculate x and y offsets; since FreeImage uses bottom-up bitmaps, the

// value of src_offset_y is measured from the bottom of the image

unsigned src_offset_x = src_left;

unsigned src_offset_y = FreeImage_GetHeight(src) - src_height - src_top;

/*

if (dst_width <= src_width) {

// xy filtering

// -------------

FIBITMAP *tmp = NULL;

if (src_width != dst_width) {

// source and destination widths are different so, we must

// filter horizontally

if (src_height != dst_height) {

// source and destination heights are also different so, we need

// a temporary image

tmp = FreeImage_AllocateT(image_type, dst_width, src_height, dst_bpp_s1, 0, 0, 0);

if (!tmp) {

FreeImage_Unload(dst);

return NULL;

}

} else {

// source and destination heights are equal so, we can directly

// scale into destination image (second filter method will not

// be invoked)

tmp = dst;

}

// scale source image horizontally into temporary (or destination) image

horizontalFilter(src, src_height, src_width, src_offset_x, src_offset_y, src_pal, tmp, dst_width);

// set x and y offsets to zero for the second filter method

// invocation (the temporary image only contains the portion of

// the image to be rescaled with no offsets)

src_offset_x = 0;

src_offset_y = 0;

// also ensure, that the second filter method gets no source

// palette (the temporary image is palletized only, if it is

// greyscale; in that case, it is an 8-bit image with a linear

// palette so, the source palette is not needed or will even be

// mismatching, if the source palette is unordered)

src_pal = NULL;

} else {

// source and destination widths are equal so, just copy the

// image pointer

tmp = src;

}

if (src_height != dst_height) {

// source and destination heights are different so, scale

// temporary (or source) image vertically into destination image

verticalFilter(tmp, dst_width, src_height, src_offset_x, src_offset_y, src_pal, dst, dst_height);

}

// free temporary image, if not pointing to either src or dst

if (tmp != src && tmp != dst) {

FreeImage_Unload(tmp);

}

} else {

// yx filtering

// -------------

// Remark:

// The yx filtering branch could be more optimized by taking into,

// account that (src_width != dst_width) is always true, which

// follows from the above condition, which selects filtering order.

// Since (dst_width <= src_width) == TRUE selects xy filtering,

// both widths must be different when performing yx filtering.

// However, to make the code more robust, not depending on that

// condition and more symmetric to the xy filtering case, these

// (src_width != dst_width) conditions are still in place.

FIBITMAP *tmp = NULL;

if (src_height != dst_height) {

// source and destination heights are different so, we must

// filter vertically

if (src_width != dst_width) {

// source and destination widths are also different so, we need

// a temporary image

tmp = FreeImage_AllocateT(image_type, src_width, dst_height, dst_bpp_s1, 0, 0, 0);

if (!tmp) {

FreeImage_Unload(dst);

return NULL;

}

} else {

// source and destination widths are equal so, we can directly

// scale into destination image (second filter method will not

// be invoked)

tmp = dst;

}

// scale source image vertically into temporary (or destination) image

verticalFilter(src, src_width, src_height, src_offset_x, src_offset_y, src_pal, tmp, dst_height);

// set x and y offsets to zero for the second filter method

// invocation (the temporary image only contains the portion of

// the image to be rescaled with no offsets)

src_offset_x = 0;

src_offset_y = 0;

// also ensure, that the second filter method gets no source

// palette (the temporary image is palletized only, if it is

// greyscale; in that case, it is an 8-bit image with a linear

// palette so, the source palette is not needed or will even be

// mismatching, if the source palette is unordered)

src_pal = NULL;

} else {

// source and destination heights are equal so, just copy the

// image pointer

tmp = src;

}

if (src_width != dst_width) {

// source and destination heights are different so, scale

// temporary (or source) image horizontally into destination image

horizontalFilter(tmp, dst_height, src_width, src_offset_x, src_offset_y, src_pal, dst, dst_width);

}

// free temporary image, if not pointing to either src or dst

if (tmp != src && tmp != dst) {

FreeImage_Unload(tmp);

}

}

return dst;

}

void CResizeEngine::horizontalFilter(FIBITMAP *const src, unsigned height, unsigned src_width, unsigned src_offset_x, unsigned src_offset_y, const RGBQUAD *const src_pal, FIBITMAP *const dst, unsigned dst_width) {