virtualx-engine/core/image.cpp

/*************************************************************************/
/*  image.cpp                                                            */
/*************************************************************************/
/*                       This file is part of:                           */
/*                           GODOT ENGINE                                */
/*                    http://www.godotengine.org                         */
/*************************************************************************/
/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
/*                                                                       */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the       */
/* "Software"), to deal in the Software without restriction, including   */
/* without limitation the rights to use, copy, modify, merge, publish,   */
/* distribute, sublicense, and/or sell copies of the Software, and to    */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions:                                             */
/*                                                                       */
/* The above copyright notice and this permission notice shall be        */
/* included in all copies or substantial portions of the Software.       */
/*                                                                       */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
/*************************************************************************/
#include "image.h"
#include "core/io/image_loader.h"
#include "core/os/copymem.h"
#include "hash_map.h"
#include "hq2x.h"
#include "print_string.h"
#include <stdio.h>

const char *Image::format_names[Image::FORMAT_MAX] = {
	"Grayscale",
	"Intensity",
	"GrayscaleAlpha",
	"RGB",
	"RGBA",
	"Indexed",
	"IndexedAlpha",
	"YUV422",
	"YUV444",
	"BC1",
	"BC2",
	"BC3",
	"BC4",
	"BC5",
	"PVRTC2",
	"PVRTC2Alpha",
	"PVRTC4",
	"PVRTC4Alpha",
	"ETC",
	"ATC",
	"ATCAlphaExp",
	"ATCAlphaInterp",

};

SavePNGFunc Image::save_png_func = NULL;

void Image::_put_pixel(int p_x, int p_y, const BColor &p_color, unsigned char *p_data) {

	_put_pixelw(p_x, p_y, width, p_color, p_data);
}

void Image::_put_pixelw(int p_x, int p_y, int p_width, const BColor &p_color, unsigned char *p_data) {

	int ofs = p_y * p_width + p_x;

	switch (format) {
		case FORMAT_GRAYSCALE: {

			p_data[ofs] = p_color.gray();
		} break;
		case FORMAT_INTENSITY: {

			p_data[ofs] = p_color.a;
		} break;
		case FORMAT_GRAYSCALE_ALPHA: {

			p_data[ofs * 2] = p_color.gray();
			p_data[ofs * 2 + 1] = p_color.a;

		} break;
		case FORMAT_RGB: {

			p_data[ofs * 3 + 0] = p_color.r;
			p_data[ofs * 3 + 1] = p_color.g;
			p_data[ofs * 3 + 2] = p_color.b;

		} break;
		case FORMAT_RGBA: {

			p_data[ofs * 4 + 0] = p_color.r;
			p_data[ofs * 4 + 1] = p_color.g;
			p_data[ofs * 4 + 2] = p_color.b;
			p_data[ofs * 4 + 3] = p_color.a;

		} break;
		case FORMAT_INDEXED:
		case FORMAT_INDEXED_ALPHA: {

			ERR_FAIL();
		} break;
		default: {};
	}
}

void Image::_get_mipmap_offset_and_size(int p_mipmap, int &r_offset, int &r_width, int &r_height) const {

	int w = width;
	int h = height;
	int ofs = 0;

	int pixel_size = get_format_pixel_size(format);
	int pixel_rshift = get_format_pixel_rshift(format);
	int minw, minh;
	_get_format_min_data_size(format, minw, minh);

	for (int i = 0; i < p_mipmap; i++) {
		int s = w * h;
		s *= pixel_size;
		s >>= pixel_rshift;
		ofs += s;
		w = MAX(minw, w >> 1);
		h = MAX(minh, h >> 1);
	}

	r_offset = ofs;
	r_width = w;
	r_height = h;
}
int Image::get_mipmap_offset(int p_mipmap) const {

	ERR_FAIL_INDEX_V(p_mipmap, (mipmaps + 1), -1);

	int ofs, w, h;
	_get_mipmap_offset_and_size(p_mipmap, ofs, w, h);
	return ofs;
}

void Image::get_mipmap_offset_and_size(int p_mipmap, int &r_ofs, int &r_size) const {

	int ofs, w, h;
	_get_mipmap_offset_and_size(p_mipmap, ofs, w, h);
	int ofs2;
	_get_mipmap_offset_and_size(p_mipmap + 1, ofs2, w, h);
	r_ofs = ofs;
	r_size = ofs2 - ofs;
}

void Image::get_mipmap_offset_size_and_dimensions(int p_mipmap, int &r_ofs, int &r_size, int &w, int &h) const {

	int ofs;
	_get_mipmap_offset_and_size(p_mipmap, ofs, w, h);
	int ofs2, w2, h2;
	_get_mipmap_offset_and_size(p_mipmap + 1, ofs2, w2, h2);
	r_ofs = ofs;
	r_size = ofs2 - ofs;
}

void Image::put_pixel(int p_x, int p_y, const Color &p_color, int p_mipmap) {

	ERR_FAIL_INDEX(p_mipmap, mipmaps + 1);
	int ofs, w, h;
	_get_mipmap_offset_and_size(p_mipmap, ofs, w, h);
	ERR_FAIL_INDEX(p_x, w);
	ERR_FAIL_INDEX(p_y, h);

	DVector<uint8_t>::Write wp = data.write();
	unsigned char *data_ptr = wp.ptr();

	_put_pixelw(p_x, p_y, w, BColor(p_color.r * 255, p_color.g * 255, p_color.b * 255, p_color.a * 255), &data_ptr[ofs]);
}

Image::BColor Image::_get_pixel(int p_x, int p_y, const unsigned char *p_data, int p_data_size) const {

	return _get_pixelw(p_x, p_y, width, p_data, p_data_size);
}
Image::BColor Image::_get_pixelw(int p_x, int p_y, int p_width, const unsigned char *p_data, int p_data_size) const {

	int ofs = p_y * p_width + p_x;
	BColor result(0, 0, 0, 0);
	switch (format) {

		case FORMAT_GRAYSCALE: {

			result = BColor(p_data[ofs], p_data[ofs], p_data[ofs], 255.0);
		} break;
		case FORMAT_INTENSITY: {

			result = BColor(255, 255, 255, p_data[ofs]);
		} break;
		case FORMAT_GRAYSCALE_ALPHA: {

			result = BColor(p_data[ofs * 2], p_data[ofs * 2], p_data[ofs * 2], p_data[ofs * 2 + 1]);

		} break;
		case FORMAT_RGB: {

			result = BColor(p_data[ofs * 3], p_data[ofs * 3 + 1], p_data[ofs * 3 + 2]);

		} break;
		case FORMAT_RGBA: {

			result = BColor(p_data[ofs * 4], p_data[ofs * 4 + 1], p_data[ofs * 4 + 2], p_data[ofs * 4 + 3]);
		} break;
		case FORMAT_INDEXED_ALPHA: {

			int pitch = 4;
			const uint8_t *pal = &p_data[p_data_size - pitch * 256];
			int idx = p_data[ofs];
			result = BColor(pal[idx * pitch + 0], pal[idx * pitch + 1], pal[idx * pitch + 2], pal[idx * pitch + 3]);

		} break;
		case FORMAT_INDEXED: {

			int pitch = 3;
			const uint8_t *pal = &p_data[p_data_size - pitch * 256];
			int idx = p_data[ofs];
			result = BColor(pal[idx * pitch + 0], pal[idx * pitch + 1], pal[idx * pitch + 2], 255);
		} break;
		case FORMAT_YUV_422: {

			int y, u, v;
			if (p_x % 2) {
				const uint8_t *yp = &p_data[p_width * 2 * p_y + p_x * 2];
				u = *(yp - 1);
				y = yp[0];
				v = yp[1];
			} else {

				const uint8_t *yp = &p_data[p_width * 2 * p_y + p_x * 2];
				y = yp[0];
				u = yp[1];
				v = yp[3];
			};

			int32_t r = 1.164 * (y - 16) + 1.596 * (v - 128);
			int32_t g = 1.164 * (y - 16) - 0.813 * (v - 128) - 0.391 * (u - 128);
			int32_t b = 1.164 * (y - 16) + 2.018 * (u - 128);
			result = BColor(CLAMP(r, 0, 255), CLAMP(g, 0, 255), CLAMP(b, 0, 255));
		} break;
		case FORMAT_YUV_444: {

			uint8_t y, u, v;
			const uint8_t *yp = &p_data[p_width * 3 * p_y + p_x * 3];
			y = yp[0];
			u = yp[1];
			v = yp[2];

			int32_t r = 1.164 * (y - 16) + 1.596 * (v - 128);
			int32_t g = 1.164 * (y - 16) - 0.813 * (v - 128) - 0.391 * (u - 128);
			int32_t b = 1.164 * (y - 16) + 2.018 * (u - 128);
			result = BColor(CLAMP(r, 0, 255), CLAMP(g, 0, 255), CLAMP(b, 0, 255));
		} break;
		default: {}
	}

	return result;
}

void Image::put_indexed_pixel(int p_x, int p_y, uint8_t p_idx, int p_mipmap) {

	ERR_FAIL_COND(format != FORMAT_INDEXED && format != FORMAT_INDEXED_ALPHA);
	ERR_FAIL_INDEX(p_mipmap, mipmaps + 1);
	int ofs, w, h;
	_get_mipmap_offset_and_size(p_mipmap, ofs, w, h);
	ERR_FAIL_INDEX(p_x, w);
	ERR_FAIL_INDEX(p_y, h);

	data.set(ofs + p_y * w + p_x, p_idx);
};

uint8_t Image::get_indexed_pixel(int p_x, int p_y, int p_mipmap) const {

	ERR_FAIL_COND_V(format != FORMAT_INDEXED && format != FORMAT_INDEXED_ALPHA, 0);

	ERR_FAIL_INDEX_V(p_mipmap, mipmaps + 1, 0);
	int ofs, w, h;
	_get_mipmap_offset_and_size(p_mipmap, ofs, w, h);
	ERR_FAIL_INDEX_V(p_x, w, 0);
	ERR_FAIL_INDEX_V(p_y, h, 0);

	return data[ofs + p_y * w + p_x];
};

void Image::set_pallete(const DVector<uint8_t> &p_data) {

	int len = p_data.size();

	ERR_FAIL_COND(format != FORMAT_INDEXED && format != FORMAT_INDEXED_ALPHA);
	ERR_FAIL_COND(format == FORMAT_INDEXED && len != (256 * 3));
	ERR_FAIL_COND(format == FORMAT_INDEXED_ALPHA && len != (256 * 4));

	int ofs, w, h;
	_get_mipmap_offset_and_size(mipmaps + 1, ofs, w, h);

	int pal_ofs = ofs;
	data.resize(pal_ofs + p_data.size());

	DVector<uint8_t>::Write wp = data.write();
	unsigned char *dst = wp.ptr() + pal_ofs;

	DVector<uint8_t>::Read r = p_data.read();
	const unsigned char *src = r.ptr();

	copymem(dst, src, len);
};

int Image::get_width() const {

	return width;
}
int Image::get_height() const {

	return height;
}

int Image::get_mipmaps() const {

	return mipmaps;
}

Color Image::get_pixel(int p_x, int p_y, int p_mipmap) const {

	ERR_FAIL_INDEX_V(p_mipmap, mipmaps + 1, Color());
	int ofs, w, h;
	_get_mipmap_offset_and_size(p_mipmap, ofs, w, h);
	ERR_FAIL_INDEX_V(p_x, w, Color());
	ERR_FAIL_INDEX_V(p_y, h, Color());

	int len = data.size();
	DVector<uint8_t>::Read r = data.read();
	const unsigned char *data_ptr = r.ptr();
	BColor c = _get_pixelw(p_x, p_y, w, &data_ptr[ofs], len);
	return Color(c.r / 255.0, c.g / 255.0, c.b / 255.0, c.a / 255.0);
}

void Image::convert(Format p_new_format) {

	if (data.size() == 0)
		return;

	if (p_new_format == format)
		return;

	if (format >= FORMAT_BC1 || p_new_format >= FORMAT_BC1) {

		ERR_EXPLAIN("Cannot convert to <-> from compressed/custom image formats (for now).");
		ERR_FAIL();
	}

	if (p_new_format == FORMAT_INDEXED || p_new_format == FORMAT_INDEXED_ALPHA) {

		return;
	}

	Image new_img(width, height, 0, p_new_format);

	int len = data.size();

	DVector<uint8_t>::Read r = data.read();
	DVector<uint8_t>::Write w = new_img.data.write();

	const uint8_t *rptr = r.ptr();
	uint8_t *wptr = w.ptr();

	if (p_new_format == FORMAT_RGBA && format == FORMAT_INDEXED_ALPHA) {

		//optimized unquantized form
		int dataend = len - 256 * 4;
		const uint32_t *palpos = (const uint32_t *)&rptr[dataend];
		uint32_t *dst32 = (uint32_t *)wptr;

		for (int i = 0; i < dataend; i++)
			dst32[i] = palpos[rptr[i]]; //since this is read/write, endianness is not a problem

	} else {

		//this is temporary, must find a faster way to do it.
		for (int i = 0; i < width; i++)
			for (int j = 0; j < height; j++)
				new_img._put_pixel(i, j, _get_pixel(i, j, rptr, len), wptr);
	}

	r = DVector<uint8_t>::Read();
	w = DVector<uint8_t>::Write();

	bool gen_mipmaps = mipmaps > 0;

	*this = new_img;

	if (gen_mipmaps)
		generate_mipmaps();
}

Image::Format Image::get_format() const {

	return format;
}

static double _bicubic_interp_kernel(double x) {

	x = ABS(x);

	double bc = 0;

	if (x <= 1)
		bc = (1.5 * x - 2.5) * x * x + 1;
	else if (x < 2)
		bc = ((-0.5 * x + 2.5) * x - 4) * x + 2;

	return bc;
}

template <int CC>
static void _scale_cubic(const uint8_t *p_src, uint8_t *p_dst, uint32_t p_src_width, uint32_t p_src_height, uint32_t p_dst_width, uint32_t p_dst_height) {

	// get source image size
	int width = p_src_width;
	int height = p_src_height;
	double xfac = (double)width / p_dst_width;
	double yfac = (double)height / p_dst_height;
	// coordinates of source points and cooefficiens
	double ox, oy, dx, dy, k1, k2;
	int ox1, oy1, ox2, oy2;
	// destination pixel values
	// width and height decreased by 1
	int ymax = height - 1;
	int xmax = width - 1;
	// temporary pointer

	for (int y = 0; y < p_dst_height; y++) {
		// Y coordinates
		oy = (double)y * yfac - 0.5f;
		oy1 = (int)oy;
		dy = oy - (double)oy1;

		for (int x = 0; x < p_dst_width; x++) {
			// X coordinates
			ox = (double)x * xfac - 0.5f;
			ox1 = (int)ox;
			dx = ox - (double)ox1;

			// initial pixel value

			uint8_t *dst = p_dst + (y * p_dst_width + x) * CC;

			double color[CC];
			for (int i = 0; i < CC; i++) {
				color[i] = 0;
			}

			for (int n = -1; n < 3; n++) {
				// get Y cooefficient
				k1 = _bicubic_interp_kernel(dy - (double)n);

				oy2 = oy1 + n;
				if (oy2 < 0)
					oy2 = 0;
				if (oy2 > ymax)
					oy2 = ymax;

				for (int m = -1; m < 3; m++) {
					// get X cooefficient
					k2 = k1 * _bicubic_interp_kernel((double)m - dx);

					ox2 = ox1 + m;
					if (ox2 < 0)
						ox2 = 0;
					if (ox2 > xmax)
						ox2 = xmax;

					// get pixel of original image
					const uint8_t *p = p_src + (oy2 * p_src_width + ox2) * CC;

					for (int i = 0; i < CC; i++) {

						color[i] += p[i] * k2;
					}
				}
			}

			for (int i = 0; i < CC; i++) {
				dst[i] = CLAMP(Math::fast_ftoi(color[i]), 0, 255);
			}
		}
	}
}

template <int CC>
static void _scale_bilinear(const uint8_t *p_src, uint8_t *p_dst, uint32_t p_src_width, uint32_t p_src_height, uint32_t p_dst_width, uint32_t p_dst_height) {

	enum {
		FRAC_BITS = 8,
		FRAC_LEN = (1 << FRAC_BITS),
		FRAC_MASK = FRAC_LEN - 1

	};

	for (uint32_t i = 0; i < p_dst_height; i++) {

		uint32_t src_yofs_up_fp = (i * p_src_height * FRAC_LEN / p_dst_height);
		uint32_t src_yofs_frac = src_yofs_up_fp & FRAC_MASK;
		uint32_t src_yofs_up = src_yofs_up_fp >> FRAC_BITS;

		uint32_t src_yofs_down = (i + 1) * p_src_height / p_dst_height;
		if (src_yofs_down >= p_src_height)
			src_yofs_down = p_src_height - 1;

		//src_yofs_up*=CC;
		//src_yofs_down*=CC;

		uint32_t y_ofs_up = src_yofs_up * p_src_width * CC;
		uint32_t y_ofs_down = src_yofs_down * p_src_width * CC;

		for (uint32_t j = 0; j < p_dst_width; j++) {

			uint32_t src_xofs_left_fp = (j * p_src_width * FRAC_LEN / p_dst_width);
			uint32_t src_xofs_frac = src_xofs_left_fp & FRAC_MASK;
			uint32_t src_xofs_left = src_xofs_left_fp >> FRAC_BITS;
			uint32_t src_xofs_right = (j + 1) * p_src_width / p_dst_width;
			if (src_xofs_right >= p_src_width)
				src_xofs_right = p_src_width - 1;

			src_xofs_left *= CC;
			src_xofs_right *= CC;

			for (uint32_t l = 0; l < CC; l++) {

				uint32_t p00 = p_src[y_ofs_up + src_xofs_left + l] << FRAC_BITS;
				uint32_t p10 = p_src[y_ofs_up + src_xofs_right + l] << FRAC_BITS;
				uint32_t p01 = p_src[y_ofs_down + src_xofs_left + l] << FRAC_BITS;
				uint32_t p11 = p_src[y_ofs_down + src_xofs_right + l] << FRAC_BITS;

				uint32_t interp_up = p00 + (((p10 - p00) * src_xofs_frac) >> FRAC_BITS);
				uint32_t interp_down = p01 + (((p11 - p01) * src_xofs_frac) >> FRAC_BITS);
				uint32_t interp = interp_up + (((interp_down - interp_up) * src_yofs_frac) >> FRAC_BITS);
				interp >>= FRAC_BITS;
				p_dst[i * p_dst_width * CC + j * CC + l] = interp;
			}
		}
	}
}

template <int CC>
static void _scale_nearest(const uint8_t *p_src, uint8_t *p_dst, uint32_t p_src_width, uint32_t p_src_height, uint32_t p_dst_width, uint32_t p_dst_height) {

	for (uint32_t i = 0; i < p_dst_height; i++) {

		uint32_t src_yofs = i * p_src_height / p_dst_height;
		uint32_t y_ofs = src_yofs * p_src_width * CC;

		for (uint32_t j = 0; j < p_dst_width; j++) {

			uint32_t src_xofs = j * p_src_width / p_dst_width;
			src_xofs *= CC;

			for (uint32_t l = 0; l < CC; l++) {

				uint32_t p = p_src[y_ofs + src_xofs + l];
				p_dst[i * p_dst_width * CC + j * CC + l] = p;
			}
		}
	}
}

void Image::resize_to_po2(bool p_square) {

	if (!_can_modify(format)) {
		ERR_EXPLAIN("Cannot resize in indexed, compressed or custom image formats.");
		ERR_FAIL();
	}

	int w = nearest_power_of_2(width);
	int h = nearest_power_of_2(height);

	if (w == width && h == height) {

		if (!p_square || w == h)
			return; //nothing to do
	}

	resize(w, h);
}

Image Image::resized(int p_width, int p_height, int p_interpolation) {

	Image ret = *this;
	ret.resize(p_width, p_height, (Interpolation)p_interpolation);

	return ret;
};

void Image::resize(int p_width, int p_height, Interpolation p_interpolation) {

	if (!_can_modify(format)) {
		ERR_EXPLAIN("Cannot resize in indexed, compressed or custom image formats.");
		ERR_FAIL();
	}

	ERR_FAIL_COND(p_width <= 0);
	ERR_FAIL_COND(p_height <= 0);
	ERR_FAIL_COND(p_width > MAX_WIDTH);
	ERR_FAIL_COND(p_height > MAX_HEIGHT);

	if (p_width == width && p_height == height)
		return;

	Image dst(p_width, p_height, 0, format);

	if (format == FORMAT_INDEXED)
		p_interpolation = INTERPOLATE_NEAREST;

	DVector<uint8_t>::Read r = data.read();
	const unsigned char *r_ptr = r.ptr();

	DVector<uint8_t>::Write w = dst.data.write();
	unsigned char *w_ptr = w.ptr();

	switch (p_interpolation) {

		case INTERPOLATE_NEAREST: {

			switch (get_format_pixel_size(format)) {
				case 1: _scale_nearest<1>(r_ptr, w_ptr, width, height, p_width, p_height); break;
				case 2: _scale_nearest<2>(r_ptr, w_ptr, width, height, p_width, p_height); break;
				case 3: _scale_nearest<3>(r_ptr, w_ptr, width, height, p_width, p_height); break;
				case 4: _scale_nearest<4>(r_ptr, w_ptr, width, height, p_width, p_height); break;
			}
		} break;
		case INTERPOLATE_BILINEAR: {

			switch (get_format_pixel_size(format)) {
				case 1: _scale_bilinear<1>(r_ptr, w_ptr, width, height, p_width, p_height); break;
				case 2: _scale_bilinear<2>(r_ptr, w_ptr, width, height, p_width, p_height); break;
				case 3: _scale_bilinear<3>(r_ptr, w_ptr, width, height, p_width, p_height); break;
				case 4: _scale_bilinear<4>(r_ptr, w_ptr, width, height, p_width, p_height); break;
			}

		} break;
		case INTERPOLATE_CUBIC: {

			switch (get_format_pixel_size(format)) {
				case 1: _scale_cubic<1>(r_ptr, w_ptr, width, height, p_width, p_height); break;
				case 2: _scale_cubic<2>(r_ptr, w_ptr, width, height, p_width, p_height); break;
				case 3: _scale_cubic<3>(r_ptr, w_ptr, width, height, p_width, p_height); break;
				case 4: _scale_cubic<4>(r_ptr, w_ptr, width, height, p_width, p_height); break;
			}

		} break;
	}

	r = DVector<uint8_t>::Read();
	w = DVector<uint8_t>::Write();

	if (mipmaps > 0)
		dst.generate_mipmaps();

	*this = dst;
}
void Image::crop(int p_width, int p_height) {

	if (!_can_modify(format)) {
		ERR_EXPLAIN("Cannot crop in indexed, compressed or custom image formats.");
		ERR_FAIL();
	}
	ERR_FAIL_COND(p_width <= 0);
	ERR_FAIL_COND(p_height <= 0);
	ERR_FAIL_COND(p_width > MAX_WIDTH);
	ERR_FAIL_COND(p_height > MAX_HEIGHT);

	/* to save memory, cropping should be done in-place, however, since this function
	   will most likely either not be used much, or in critical areas, for now it wont, because
	   it's a waste of time. */

	if (p_width == width && p_height == height)
		return;

	Image dst(p_width, p_height, 0, format);

	for (int y = 0; y < p_height; y++) {

		for (int x = 0; x < p_width; x++) {

			Color col = (x >= width || y >= height) ? Color() : get_pixel(x, y);
			dst.put_pixel(x, y, col);
		}
	}

	if (mipmaps > 0)
		dst.generate_mipmaps();
	*this = dst;
}

void Image::flip_y() {

	if (!_can_modify(format)) {
		ERR_EXPLAIN("Cannot flip_y in indexed, compressed or custom image formats.");
		ERR_FAIL();
	}

	bool gm = mipmaps;

	if (gm)
		clear_mipmaps();

	for (int y = 0; y < (height / 2); y++) {

		for (int x = 0; x < width; x++) {

			Color up = get_pixel(x, y);
			Color down = get_pixel(x, height - y - 1);

			put_pixel(x, y, down);
			put_pixel(x, height - y - 1, up);
		}
	}
	if (gm)
		generate_mipmaps();
}

void Image::flip_x() {

	if (!_can_modify(format)) {
		ERR_EXPLAIN("Cannot flip_x in indexed, compressed or custom image formats.");
		ERR_FAIL();
	}

	bool gm = mipmaps;
	if (gm)
		clear_mipmaps();

	for (int y = 0; y < (height / 2); y++) {

		for (int x = 0; x < width; x++) {

			Color up = get_pixel(x, y);
			Color down = get_pixel(width - x - 1, y);

			put_pixel(x, y, down);
			put_pixel(width - x - 1, y, up);
		}
	}

	if (gm)
		generate_mipmaps();
}

int Image::_get_dst_image_size(int p_width, int p_height, Format p_format, int &r_mipmaps, int p_mipmaps) {

	int size = 0;
	int w = p_width;
	int h = p_height;
	int mm = 0;

	int pixsize = get_format_pixel_size(p_format);
	int pixshift = get_format_pixel_rshift(p_format);
	int minw, minh;
	_get_format_min_data_size(p_format, minw, minh);

	switch (p_format) {

		case FORMAT_INDEXED:
			pixsize = 1;
			size = 256 * 3;
			break;
		case FORMAT_INDEXED_ALPHA:
			pixsize = 1;
			size = 256 * 4;
			break;
		default: {}
	};

	while (true) {

		int s = w * h;
		s *= pixsize;
		s >>= pixshift;

		size += s;

		if (p_mipmaps >= 0 && mm == p_mipmaps)
			break;

		if (p_mipmaps >= 0) {

			w = MAX(minw, w >> 1);
			h = MAX(minh, h >> 1);
		} else {
			if (w == minw && h == minh)
				break;
			w = MAX(minw, w >> 1);
			h = MAX(minh, h >> 1);
		}
		mm++;
	};

	r_mipmaps = mm;
	return size;
}

bool Image::_can_modify(Format p_format) const {

	switch (p_format) {

		//these are OK
		case FORMAT_GRAYSCALE:
		case FORMAT_INTENSITY:
		case FORMAT_GRAYSCALE_ALPHA:
		case FORMAT_RGB:
		case FORMAT_RGBA:
			return true;
		default:
			return false;
	}

	return false;
}

template <int CC>
static void _generate_po2_mipmap(const uint8_t *p_src, uint8_t *p_dst, uint32_t p_width, uint32_t p_height) {

	//fast power of 2 mipmap generation
	uint32_t dst_w = p_width >> 1;
	uint32_t dst_h = p_height >> 1;

	for (uint32_t i = 0; i < dst_h; i++) {

		const uint8_t *rup_ptr = &p_src[i * 2 * p_width * CC];
		const uint8_t *rdown_ptr = rup_ptr + p_width * CC;
		uint8_t *dst_ptr = &p_dst[i * dst_w * CC];
		uint32_t count = dst_w;

		while (count--) {

			for (int j = 0; j < CC; j++) {

				uint16_t val = 0;
				val += rup_ptr[j];
				val += rup_ptr[j + CC];
				val += rdown_ptr[j];
				val += rdown_ptr[j + CC];
				dst_ptr[j] = val >> 2;
			}

			dst_ptr += CC;
			rup_ptr += CC * 2;
			rdown_ptr += CC * 2;
		}
	}
}

void Image::expand_x2_hq2x() {

	ERR_FAIL_COND(format >= FORMAT_INDEXED);

	Format current = format;
	bool mipmaps = get_mipmaps();
	if (mipmaps) {
		clear_mipmaps();
	}

	if (current != FORMAT_RGBA)
		convert(FORMAT_RGBA);

	DVector<uint8_t> dest;
	dest.resize(width * 2 * height * 2 * 4);

	{
		DVector<uint8_t>::Read r = data.read();
		DVector<uint8_t>::Write w = dest.write();

		hq2x_resize((const uint32_t *)r.ptr(), width, height, (uint32_t *)w.ptr());
	}

	width *= 2;
	height *= 2;
	data = dest;

	if (current != FORMAT_RGBA)
		convert(current);

	if (mipmaps) {
		generate_mipmaps();
	}
}

void Image::shrink_x2() {

	ERR_FAIL_COND(format == FORMAT_INDEXED || format == FORMAT_INDEXED_ALPHA);
	ERR_FAIL_COND(data.size() == 0);

	if (mipmaps) {

		//just use the lower mipmap as base and copy all
		DVector<uint8_t> new_img;

		int ofs = get_mipmap_offset(1);

		int new_size = data.size() - ofs;
		new_img.resize(new_size);

		{
			DVector<uint8_t>::Write w = new_img.write();
			DVector<uint8_t>::Read r = data.read();

			copymem(w.ptr(), &r[ofs], new_size);
		}

		mipmaps--;
		width /= 2;
		height /= 2;
		data = new_img;

	} else {

		DVector<uint8_t> new_img;

		ERR_FAIL_COND(format >= FORMAT_INDEXED);
		int ps = get_format_pixel_size(format);
		new_img.resize((width / 2) * (height / 2) * ps);

		{
			DVector<uint8_t>::Write w = new_img.write();
			DVector<uint8_t>::Read r = data.read();

			switch (format) {

				case FORMAT_GRAYSCALE:
				case FORMAT_INTENSITY: _generate_po2_mipmap<1>(r.ptr(), w.ptr(), width, height); break;
				case FORMAT_GRAYSCALE_ALPHA: _generate_po2_mipmap<2>(r.ptr(), w.ptr(), width, height); break;
				case FORMAT_RGB: _generate_po2_mipmap<3>(r.ptr(), w.ptr(), width, height); break;
				case FORMAT_RGBA: _generate_po2_mipmap<4>(r.ptr(), w.ptr(), width, height); break;
				default: {}
			}
		}

		width /= 2;
		height /= 2;
		data = new_img;
	}
}

Error Image::generate_mipmaps(int p_mipmaps, bool p_keep_existing) {

	if (!_can_modify(format)) {
		ERR_EXPLAIN("Cannot generate mipmaps in indexed, compressed or custom image formats.");
		ERR_FAIL_V(ERR_UNAVAILABLE);
	}

	int from_mm = 1;
	if (p_keep_existing) {
		from_mm = mipmaps + 1;
	}
	int size = _get_dst_image_size(width, height, format, mipmaps, p_mipmaps);

	data.resize(size);

	DVector<uint8_t>::Write wp = data.write();

	if (nearest_power_of_2(width) == uint32_t(width) && nearest_power_of_2(height) == uint32_t(height)) {
		//use fast code for powers of 2
		int prev_ofs = 0;
		int prev_h = height;
		int prev_w = width;

		for (int i = 1; i < mipmaps; i++) {

			int ofs, w, h;
			_get_mipmap_offset_and_size(i, ofs, w, h);

			if (i >= from_mm) {

				switch (format) {

					case FORMAT_GRAYSCALE:
					case FORMAT_INTENSITY: _generate_po2_mipmap<1>(&wp[prev_ofs], &wp[ofs], prev_w, prev_h); break;
					case FORMAT_GRAYSCALE_ALPHA: _generate_po2_mipmap<2>(&wp[prev_ofs], &wp[ofs], prev_w, prev_h); break;
					case FORMAT_RGB: _generate_po2_mipmap<3>(&wp[prev_ofs], &wp[ofs], prev_w, prev_h); break;
					case FORMAT_RGBA: _generate_po2_mipmap<4>(&wp[prev_ofs], &wp[ofs], prev_w, prev_h); break;
					default: {}
				}
			}

			prev_ofs = ofs;
			prev_w = w;
			prev_h = h;
		}

	} else {
		//use slow code..

		//use bilinear filtered code for non powers of 2
		int prev_ofs = 0;
		int prev_h = height;
		int prev_w = width;

		for (int i = 1; i < mipmaps; i++) {

			int ofs, w, h;
			_get_mipmap_offset_and_size(i, ofs, w, h);

			if (i >= from_mm) {

				switch (format) {

					case FORMAT_GRAYSCALE:
					case FORMAT_INTENSITY: _scale_bilinear<1>(&wp[prev_ofs], &wp[ofs], prev_w, prev_h, w, h); break;
					case FORMAT_GRAYSCALE_ALPHA: _scale_bilinear<2>(&wp[prev_ofs], &wp[ofs], prev_w, prev_h, w, h); break;
					case FORMAT_RGB: _scale_bilinear<3>(&wp[prev_ofs], &wp[ofs], prev_w, prev_h, w, h); break;
					case FORMAT_RGBA: _scale_bilinear<4>(&wp[prev_ofs], &wp[ofs], prev_w, prev_h, w, h); break;
					default: {}
				}
			}

			prev_ofs = ofs;
			prev_w = w;
			prev_h = h;
		}
	}

	return OK;
}

void Image::clear_mipmaps() {

	if (mipmaps == 0)
		return;

	if (format == FORMAT_CUSTOM) {
		ERR_EXPLAIN("Cannot clear mipmaps in indexed, compressed or custom image formats.");
		ERR_FAIL();
	}

	if (empty())
		return;

	int ofs, w, h;
	_get_mipmap_offset_and_size(1, ofs, w, h);
	int palsize = get_format_pallete_size(format);
	DVector<uint8_t> pallete;
	ERR_FAIL_COND(ofs + palsize > data.size()); //bug?
	if (palsize) {

		pallete.resize(palsize);
		DVector<uint8_t>::Read r = data.read();
		DVector<uint8_t>::Write w = pallete.write();

		copymem(&w[0], &r[data.size() - palsize], palsize);
	}

	data.resize(ofs + palsize);

	if (palsize) {

		DVector<uint8_t>::Read r = pallete.read();
		DVector<uint8_t>::Write w = data.write();

		copymem(&w[ofs], &r[0], palsize);
	}

	mipmaps = 0;
}

void Image::make_normalmap(float p_height_scale) {

	if (!_can_modify(format)) {
		ERR_EXPLAIN("Cannot crop in indexed, compressed or custom image formats.");
		ERR_FAIL();
	}

	ERR_FAIL_COND(empty());

	Image normalmap(width, height, 0, FORMAT_RGB);
	/*
	for (int y=0;y<height;y++) {
		for (int x=0;x<width;x++) {

			float center=get_pixel(x,y).gray()/255.0;
			float up=(y>0)?get_pixel(x,y-1).gray()/255.0:center;
			float down=(y<(height-1))?get_pixel(x,y+1).gray()/255.0:center;
			float left=(x>0)?get_pixel(x-1,y).gray()/255.0:center;
			float right=(x<(width-1))?get_pixel(x+1,y).gray()/255.0:center;


			// uhm, how do i do this? ....

			Color result( (uint8_t)((normal.x+1.0)*127.0), (uint8_t)((normal.y+1.0)*127.0), (uint8_t)((normal.z+1.0)*127.0) );

			normalmap.put_pixel( x, y, result );
		}

	}
	*/
	*this = normalmap;
}

bool Image::empty() const {

	return (data.size() == 0);
}

DVector<uint8_t> Image::get_data() const {

	return data;
}

void Image::create(int p_width, int p_height, bool p_use_mipmaps, Format p_format) {

	int mm = 0;
	int size = _get_dst_image_size(p_width, p_height, p_format, mm, p_use_mipmaps ? -1 : 0);
	data.resize(size);
	{
		DVector<uint8_t>::Write w = data.write();
		zeromem(w.ptr(), size);
	}

	width = p_width;
	height = p_height;
	mipmaps = mm;
	format = p_format;
}

void Image::create(int p_width, int p_height, int p_mipmaps, Format p_format, const DVector<uint8_t> &p_data) {

	ERR_FAIL_INDEX(p_width - 1, MAX_WIDTH);
	ERR_FAIL_INDEX(p_height - 1, MAX_HEIGHT);

	if (p_format < FORMAT_CUSTOM) {
		int mm;
		int size = _get_dst_image_size(p_width, p_height, p_format, mm, p_mipmaps);

		if (size != p_data.size()) {
			ERR_EXPLAIN("Expected data size of " + itos(size) + " in Image::create()");
			ERR_FAIL_COND(p_data.size() != size);
		}
	};

	height = p_height;
	width = p_width;
	format = p_format;
	data = p_data;
	mipmaps = p_mipmaps;
}

void Image::create(const char **p_xpm) {

	int size_width, size_height;
	int pixelchars = 0;
	mipmaps = 0;
	bool has_alpha = false;

	enum Status {
		READING_HEADER,
		READING_COLORS,
		READING_PIXELS,
		DONE
	};

	Status status = READING_HEADER;
	int line = 0;

	HashMap<String, Color> colormap;
	int colormap_size;

	while (status != DONE) {

		const char *line_ptr = p_xpm[line];

		switch (status) {

			case READING_HEADER: {

				String line_str = line_ptr;
				line_str.replace("\t", " ");

				size_width = line_str.get_slicec(' ', 0).to_int();
				size_height = line_str.get_slicec(' ', 1).to_int();
				colormap_size = line_str.get_slicec(' ', 2).to_int();
				pixelchars = line_str.get_slicec(' ', 3).to_int();
				ERR_FAIL_COND(colormap_size > 32766);
				ERR_FAIL_COND(pixelchars > 5);
				ERR_FAIL_COND(size_width > 32767);
				ERR_FAIL_COND(size_height > 32767);
				status = READING_COLORS;
			} break;
			case READING_COLORS: {

				String colorstring;
				for (int i = 0; i < pixelchars; i++) {

					colorstring += *line_ptr;
					line_ptr++;
				}
				//skip spaces
				while (*line_ptr == ' ' || *line_ptr == '\t' || *line_ptr == 0) {
					if (*line_ptr == 0)
						break;
					line_ptr++;
				}
				if (*line_ptr == 'c') {

					line_ptr++;
					while (*line_ptr == ' ' || *line_ptr == '\t' || *line_ptr == 0) {
						if (*line_ptr == 0)
							break;
						line_ptr++;
					}

					if (*line_ptr == '#') {
						line_ptr++;
						uint8_t col_r;
						uint8_t col_g;
						uint8_t col_b;
						//					uint8_t col_a=255;

						for (int i = 0; i < 6; i++) {

							char v = line_ptr[i];

							if (v >= '0' && v <= '9')
								v -= '0';
							else if (v >= 'A' && v <= 'F')
								v = (v - 'A') + 10;
							else if (v >= 'a' && v <= 'f')
								v = (v - 'a') + 10;
							else
								break;

							switch (i) {
								case 0: col_r = v << 4; break;
								case 1: col_r |= v; break;
								case 2: col_g = v << 4; break;
								case 3: col_g |= v; break;
								case 4: col_b = v << 4; break;
								case 5: col_b |= v; break;
							};
						}

						// magenta mask
						if (col_r == 255 && col_g == 0 && col_b == 255) {

							colormap[colorstring] = Color(0, 0, 0, 0);
							has_alpha = true;
						} else {

							colormap[colorstring] = Color(col_r / 255.0, col_g / 255.0, col_b / 255.0, 1.0);
						}
					}
				}
				if (line == colormap_size) {

					status = READING_PIXELS;
					create(size_width, size_height, 0, has_alpha ? FORMAT_RGBA : FORMAT_RGB);
				}
			} break;
			case READING_PIXELS: {

				int y = line - colormap_size - 1;
				for (int x = 0; x < size_width; x++) {

					char pixelstr[6] = { 0, 0, 0, 0, 0, 0 };
					for (int i = 0; i < pixelchars; i++)
						pixelstr[i] = line_ptr[x * pixelchars + i];

					Color *colorptr = colormap.getptr(pixelstr);
					ERR_FAIL_COND(!colorptr);
					put_pixel(x, y, *colorptr);
				}

				if (y == (size_height - 1))
					status = DONE;
			} break;
			default: {}
		}

		line++;
	}
}
#define DETECT_ALPHA_MAX_TRESHOLD 254
#define DETECT_ALPHA_MIN_TRESHOLD 2

#define DETECT_ALPHA(m_value)                         \
	{                                                 \
		uint8_t value = m_value;                      \
		if (value < DETECT_ALPHA_MIN_TRESHOLD)        \
			bit = true;                               \
		else if (value < DETECT_ALPHA_MAX_TRESHOLD) { \
                                                      \
			detected = true;                          \
			break;                                    \
		}                                             \
	}

#define DETECT_NON_ALPHA(m_value) \
	{                             \
		uint8_t value = m_value;  \
		if (value > 0) {          \
                                  \
			detected = true;      \
			break;                \
		}                         \
	}

bool Image::is_invisible() const {

	if (format == FORMAT_GRAYSCALE ||
			format == FORMAT_RGB ||
			format == FORMAT_INDEXED)
		return false;

	int len = data.size();

	if (len == 0)
		return true;

	if (format >= FORMAT_YUV_422 && format <= FORMAT_YUV_444)
		return false;

	int w, h;
	_get_mipmap_offset_and_size(1, len, w, h);

	DVector<uint8_t>::Read r = data.read();
	const unsigned char *data_ptr = r.ptr();

	bool detected = false;

	switch (format) {
		case FORMAT_INTENSITY: {

			for (int i = 0; i < len; i++) {
				DETECT_NON_ALPHA(data_ptr[i]);
			}
		} break;
		case FORMAT_GRAYSCALE_ALPHA: {

			for (int i = 0; i < (len >> 1); i++) {
				DETECT_NON_ALPHA(data_ptr[(i << 1) + 1]);
			}

		} break;
		case FORMAT_RGBA: {

			for (int i = 0; i < (len >> 2); i++) {
				DETECT_NON_ALPHA(data_ptr[(i << 2) + 3])
			}

		} break;
		case FORMAT_INDEXED: {

			return false;
		} break;
		case FORMAT_INDEXED_ALPHA: {

			return false;
		} break;
		case FORMAT_PVRTC2_ALPHA:
		case FORMAT_PVRTC4_ALPHA:
		case FORMAT_BC2:
		case FORMAT_BC3: {
			detected = true;
		} break;
		default: {}
	}

	return !detected;
}

Image::AlphaMode Image::detect_alpha() const {

	if (format == FORMAT_GRAYSCALE ||
			format == FORMAT_RGB ||
			format == FORMAT_INDEXED)
		return ALPHA_NONE;

	int len = data.size();

	if (len == 0)
		return ALPHA_NONE;

	if (format >= FORMAT_YUV_422 && format <= FORMAT_YUV_444)
		return ALPHA_NONE;

	int w, h;
	_get_mipmap_offset_and_size(1, len, w, h);

	DVector<uint8_t>::Read r = data.read();
	const unsigned char *data_ptr = r.ptr();

	bool bit = false;
	bool detected = false;

	switch (format) {
		case FORMAT_INTENSITY: {

			for (int i = 0; i < len; i++) {
				DETECT_ALPHA(data_ptr[i]);
			}
		} break;
		case FORMAT_GRAYSCALE_ALPHA: {

			for (int i = 0; i < (len >> 1); i++) {
				DETECT_ALPHA(data_ptr[(i << 1) + 1]);
			}

		} break;
		case FORMAT_RGBA: {

			for (int i = 0; i < (len >> 2); i++) {
				DETECT_ALPHA(data_ptr[(i << 2) + 3])
			}

		} break;
		case FORMAT_INDEXED: {

			return ALPHA_NONE;
		} break;
		case FORMAT_INDEXED_ALPHA: {

			return ALPHA_BLEND;
		} break;
		case FORMAT_PVRTC2_ALPHA:
		case FORMAT_PVRTC4_ALPHA:
		case FORMAT_BC2:
		case FORMAT_BC3: {
			detected = true;
		} break;
		default: {}
	}

	if (detected)
		return ALPHA_BLEND;
	else if (bit)
		return ALPHA_BIT;
	else
		return ALPHA_NONE;
}

Error Image::load(const String &p_path) {

	return ImageLoader::load_image(p_path, this);
}

Error Image::save_png(const String &p_path) {

	if (save_png_func == NULL)
		return ERR_UNAVAILABLE;

	return save_png_func(p_path, *this);
};

bool Image::operator==(const Image &p_image) const {

	if (data.size() == 0 && p_image.data.size() == 0)
		return true;
	DVector<uint8_t>::Read r = data.read();
	DVector<uint8_t>::Read pr = p_image.data.read();

	return r.ptr() == pr.ptr();
}

int Image::get_format_pixel_size(Format p_format) {

	switch (p_format) {
		case FORMAT_GRAYSCALE: {

			return 1;
		} break;
		case FORMAT_INTENSITY: {

			return 1;
		} break;
		case FORMAT_GRAYSCALE_ALPHA: {

			return 2;
		} break;
		case FORMAT_RGB: {

			return 3;
		} break;
		case FORMAT_RGBA: {

			return 4;
		} break;
		case FORMAT_INDEXED: {

			return 1;
		} break;
		case FORMAT_INDEXED_ALPHA: {

			return 1;
		} break;
		case FORMAT_BC1:
		case FORMAT_BC2:
		case FORMAT_BC3:
		case FORMAT_BC4:
		case FORMAT_BC5: {

			return 1;
		} break;
		case FORMAT_PVRTC2:
		case FORMAT_PVRTC2_ALPHA: {

			return 1;
		} break;
		case FORMAT_PVRTC4:
		case FORMAT_PVRTC4_ALPHA: {

			return 1;
		} break;
		case FORMAT_ATC:
		case FORMAT_ATC_ALPHA_EXPLICIT:
		case FORMAT_ATC_ALPHA_INTERPOLATED: {

			return 1;
		} break;
		case FORMAT_ETC: {

			return 1;
		} break;
		case FORMAT_YUV_422: {
			return 2;
		};
		case FORMAT_YUV_444: {
			return 3;
		} break;
		case FORMAT_CUSTOM: {

			ERR_EXPLAIN("pixel size requested for custom image format, and it's unknown obviously");
			ERR_FAIL_V(1);
		} break;
		default: {
			ERR_EXPLAIN("Cannot obtain pixel size from this format");
			ERR_FAIL_V(1);
		}
	}
	return 0;
}

int Image::get_image_data_size(int p_width, int p_height, Format p_format, int p_mipmaps) {

	int mm;
	return _get_dst_image_size(p_width, p_height, p_format, mm, p_mipmaps);
}

int Image::get_image_required_mipmaps(int p_width, int p_height, Format p_format) {

	int mm;
	_get_dst_image_size(p_width, p_height, p_format, mm, -1);
	return mm;
}

void Image::_get_format_min_data_size(Format p_format, int &r_w, int &r_h) {

	switch (p_format) {
		case FORMAT_BC1:
		case FORMAT_BC2:
		case FORMAT_BC3:
		case FORMAT_BC4:
		case FORMAT_BC5: {
			r_w = 4;
			r_h = 4;
		} break;
		case FORMAT_PVRTC2:
		case FORMAT_PVRTC2_ALPHA: {

			r_w = 16;
			r_h = 8;
		} break;
		case FORMAT_PVRTC4_ALPHA:
		case FORMAT_PVRTC4: {

			r_w = 8;
			r_h = 8;
		} break;
		case FORMAT_ATC:
		case FORMAT_ATC_ALPHA_EXPLICIT:
		case FORMAT_ATC_ALPHA_INTERPOLATED: {

			r_w = 8;
			r_h = 8;

		} break;

		case FORMAT_ETC: {

			r_w = 4;
			r_h = 4;
		} break;
		default: {
			r_w = 1;
			r_h = 1;
		} break;
	}
}

int Image::get_format_pixel_rshift(Format p_format) {

	if (p_format == FORMAT_BC1 || p_format == FORMAT_BC4 || p_format == FORMAT_ATC || p_format == FORMAT_PVRTC4 || p_format == FORMAT_PVRTC4_ALPHA || p_format == FORMAT_ETC)
		return 1;
	else if (p_format == FORMAT_PVRTC2 || p_format == FORMAT_PVRTC2_ALPHA)
		return 2;
	else
		return 0;
}

int Image::get_format_pallete_size(Format p_format) {

	switch (p_format) {
		case FORMAT_GRAYSCALE: {

			return 0;
		} break;
		case FORMAT_INTENSITY: {

			return 0;
		} break;
		case FORMAT_GRAYSCALE_ALPHA: {

			return 0;
		} break;
		case FORMAT_RGB: {

			return 0;
		} break;
		case FORMAT_RGBA: {

			return 0;
		} break;
		case FORMAT_INDEXED: {

			return 3 * 256;
		} break;
		case FORMAT_INDEXED_ALPHA: {

			return 4 * 256;
		} break;
		default: {}
	}
	return 0;
}

Error Image::_decompress_bc() {

	print_line("decompressing bc");

	int wd = width, ht = height;
	if (wd % 4 != 0) {
		wd += 4 - (wd % 4);
	}
	if (ht % 4 != 0) {
		ht += 4 - (ht % 4);
	}

	int mm;
	int size = _get_dst_image_size(wd, ht, FORMAT_RGBA, mm, mipmaps);

	DVector<uint8_t> newdata;
	newdata.resize(size);

	DVector<uint8_t>::Write w = newdata.write();
	DVector<uint8_t>::Read r = data.read();

	int rofs = 0;
	int wofs = 0;

	//print_line("width: "+itos(wd)+" height: "+itos(ht));

	for (int i = 0; i <= mm; i++) {

		switch (format) {

			case FORMAT_BC1: {

				int len = (wd * ht) / 16;
				uint8_t *dst = &w[wofs];

				uint32_t ofs_table[16];
				for (int x = 0; x < 4; x++) {

					for (int y = 0; y < 4; y++) {

						ofs_table[15 - (y * 4 + (3 - x))] = (x + y * wd) * 4;
					}
				}

				for (int j = 0; j < len; j++) {

					const uint8_t *src = &r[rofs + j * 8];
					uint16_t col_a = src[1];
					col_a <<= 8;
					col_a |= src[0];
					uint16_t col_b = src[3];
					col_b <<= 8;
					col_b |= src[2];

					uint8_t table[4][4] = {
						{ (col_a >> 11) << 3, ((col_a >> 5) & 0x3f) << 2, ((col_a)&0x1f) << 3, 255 },
						{ (col_b >> 11) << 3, ((col_b >> 5) & 0x3f) << 2, ((col_b)&0x1f) << 3, 255 },
						{ 0, 0, 0, 255 },
						{ 0, 0, 0, 255 }
					};

					if (col_a < col_b) {
						//punchrough
						table[2][0] = (int(table[0][0]) + int(table[1][0])) >> 1;
						table[2][1] = (int(table[0][1]) + int(table[1][1])) >> 1;
						table[2][2] = (int(table[0][2]) + int(table[1][2])) >> 1;
						table[3][3] = 0; //premul alpha black
					} else {
						//gradient
						table[2][0] = (int(table[0][0]) * 2 + int(table[1][0])) / 3;
						table[2][1] = (int(table[0][1]) * 2 + int(table[1][1])) / 3;
						table[2][2] = (int(table[0][2]) * 2 + int(table[1][2])) / 3;
						table[3][0] = (int(table[0][0]) + int(table[1][0]) * 2) / 3;
						table[3][1] = (int(table[0][1]) + int(table[1][1]) * 2) / 3;
						table[3][2] = (int(table[0][2]) + int(table[1][2]) * 2) / 3;
					}

					uint32_t block = src[4];
					block <<= 8;
					block |= src[5];
					block <<= 8;
					block |= src[6];
					block <<= 8;
					block |= src[7];

					int y = (j / (wd / 4)) * 4;
					int x = (j % (wd / 4)) * 4;
					int pixofs = (y * wd + x) * 4;

					for (int k = 0; k < 16; k++) {
						int idx = pixofs + ofs_table[k];
						dst[idx + 0] = table[block & 0x3][0];
						dst[idx + 1] = table[block & 0x3][1];
						dst[idx + 2] = table[block & 0x3][2];
						dst[idx + 3] = table[block & 0x3][3];
						block >>= 2;
					}
				}

				rofs += len * 8;
				wofs += wd * ht * 4;

				wd /= 2;
				ht /= 2;

			} break;
			case FORMAT_BC2: {

				int len = (wd * ht) / 16;
				uint8_t *dst = &w[wofs];

				uint32_t ofs_table[16];
				for (int x = 0; x < 4; x++) {

					for (int y = 0; y < 4; y++) {

						ofs_table[15 - (y * 4 + (3 - x))] = (x + y * wd) * 4;
					}
				}

				for (int j = 0; j < len; j++) {

					const uint8_t *src = &r[rofs + j * 16];

					uint64_t ablock = src[1];
					ablock <<= 8;
					ablock |= src[0];
					ablock <<= 8;
					ablock |= src[3];
					ablock <<= 8;
					ablock |= src[2];
					ablock <<= 8;
					ablock |= src[5];
					ablock <<= 8;
					ablock |= src[4];
					ablock <<= 8;
					ablock |= src[7];
					ablock <<= 8;
					ablock |= src[6];

					uint16_t col_a = src[8 + 1];
					col_a <<= 8;
					col_a |= src[8 + 0];
					uint16_t col_b = src[8 + 3];
					col_b <<= 8;
					col_b |= src[8 + 2];

					uint8_t table[4][4] = {
						{ (col_a >> 11) << 3, ((col_a >> 5) & 0x3f) << 2, ((col_a)&0x1f) << 3, 255 },
						{ (col_b >> 11) << 3, ((col_b >> 5) & 0x3f) << 2, ((col_b)&0x1f) << 3, 255 },
						{ 0, 0, 0, 255 },
						{ 0, 0, 0, 255 }
					};

					//always gradient
					table[2][0] = (int(table[0][0]) * 2 + int(table[1][0])) / 3;
					table[2][1] = (int(table[0][1]) * 2 + int(table[1][1])) / 3;
					table[2][2] = (int(table[0][2]) * 2 + int(table[1][2])) / 3;
					table[3][0] = (int(table[0][0]) + int(table[1][0]) * 2) / 3;
					table[3][1] = (int(table[0][1]) + int(table[1][1]) * 2) / 3;
					table[3][2] = (int(table[0][2]) + int(table[1][2]) * 2) / 3;

					uint32_t block = src[4 + 8];
					block <<= 8;
					block |= src[5 + 8];
					block <<= 8;
					block |= src[6 + 8];
					block <<= 8;
					block |= src[7 + 8];

					int y = (j / (wd / 4)) * 4;
					int x = (j % (wd / 4)) * 4;
					int pixofs = (y * wd + x) * 4;

					for (int k = 0; k < 16; k++) {
						uint8_t alpha = ablock & 0xf;
						alpha = int(alpha) * 255 / 15; //right way for alpha
						int idx = pixofs + ofs_table[k];
						dst[idx + 0] = table[block & 0x3][0];
						dst[idx + 1] = table[block & 0x3][1];
						dst[idx + 2] = table[block & 0x3][2];
						dst[idx + 3] = alpha;
						block >>= 2;
						ablock >>= 4;
					}
				}

				rofs += len * 16;
				wofs += wd * ht * 4;

				wd /= 2;
				ht /= 2;

			} break;
			case FORMAT_BC3: {

				int len = (wd * ht) / 16;
				uint8_t *dst = &w[wofs];

				uint32_t ofs_table[16];
				for (int x = 0; x < 4; x++) {

					for (int y = 0; y < 4; y++) {

						ofs_table[15 - (y * 4 + (3 - x))] = (x + y * wd) * 4;
					}
				}

				for (int j = 0; j < len; j++) {

					const uint8_t *src = &r[rofs + j * 16];

					uint8_t a_start = src[1];
					uint8_t a_end = src[0];

					uint64_t ablock = src[3];
					ablock <<= 8;
					ablock |= src[2];
					ablock <<= 8;
					ablock |= src[5];
					ablock <<= 8;
					ablock |= src[4];
					ablock <<= 8;
					ablock |= src[7];
					ablock <<= 8;
					ablock |= src[6];

					uint8_t atable[8];

					if (a_start > a_end) {

						atable[0] = (int(a_start) * 7 + int(a_end) * 0) / 7;
						atable[1] = (int(a_start) * 6 + int(a_end) * 1) / 7;
						atable[2] = (int(a_start) * 5 + int(a_end) * 2) / 7;
						atable[3] = (int(a_start) * 4 + int(a_end) * 3) / 7;
						atable[4] = (int(a_start) * 3 + int(a_end) * 4) / 7;
						atable[5] = (int(a_start) * 2 + int(a_end) * 5) / 7;
						atable[6] = (int(a_start) * 1 + int(a_end) * 6) / 7;
						atable[7] = (int(a_start) * 0 + int(a_end) * 7) / 7;
					} else {

						atable[0] = (int(a_start) * 5 + int(a_end) * 0) / 5;
						atable[1] = (int(a_start) * 4 + int(a_end) * 1) / 5;
						atable[2] = (int(a_start) * 3 + int(a_end) * 2) / 5;
						atable[3] = (int(a_start) * 2 + int(a_end) * 3) / 5;
						atable[4] = (int(a_start) * 1 + int(a_end) * 4) / 5;
						atable[5] = (int(a_start) * 0 + int(a_end) * 5) / 5;
						atable[6] = 0;
						atable[7] = 255;
					}

					uint16_t col_a = src[8 + 1];
					col_a <<= 8;
					col_a |= src[8 + 0];
					uint16_t col_b = src[8 + 3];
					col_b <<= 8;
					col_b |= src[8 + 2];

					uint8_t table[4][4] = {
						{ (col_a >> 11) << 3, ((col_a >> 5) & 0x3f) << 2, ((col_a)&0x1f) << 3, 255 },
						{ (col_b >> 11) << 3, ((col_b >> 5) & 0x3f) << 2, ((col_b)&0x1f) << 3, 255 },
						{ 0, 0, 0, 255 },
						{ 0, 0, 0, 255 }
					};

					//always gradient
					table[2][0] = (int(table[0][0]) * 2 + int(table[1][0])) / 3;
					table[2][1] = (int(table[0][1]) * 2 + int(table[1][1])) / 3;
					table[2][2] = (int(table[0][2]) * 2 + int(table[1][2])) / 3;
					table[3][0] = (int(table[0][0]) + int(table[1][0]) * 2) / 3;
					table[3][1] = (int(table[0][1]) + int(table[1][1]) * 2) / 3;
					table[3][2] = (int(table[0][2]) + int(table[1][2]) * 2) / 3;

					uint32_t block = src[4 + 8];
					block <<= 8;
					block |= src[5 + 8];
					block <<= 8;
					block |= src[6 + 8];
					block <<= 8;
					block |= src[7 + 8];

					int y = (j / (wd / 4)) * 4;
					int x = (j % (wd / 4)) * 4;
					int pixofs = (y * wd + x) * 4;

					for (int k = 0; k < 16; k++) {
						uint8_t alpha = ablock & 0x7;
						int idx = pixofs + ofs_table[k];
						dst[idx + 0] = table[block & 0x3][0];
						dst[idx + 1] = table[block & 0x3][1];
						dst[idx + 2] = table[block & 0x3][2];
						dst[idx + 3] = atable[alpha];
						block >>= 2;
						ablock >>= 3;
					}
				}

				rofs += len * 16;
				wofs += wd * ht * 4;

				wd /= 2;
				ht /= 2;

			} break;
		}
	}

	w = DVector<uint8_t>::Write();
	r = DVector<uint8_t>::Read();

	data = newdata;
	format = FORMAT_RGBA;
	if (wd != width || ht != height) {
		//todo, crop
		width = wd;
		height = ht;
	}

	return OK;
}

bool Image::is_compressed() const {
	return format >= FORMAT_BC1;
}

Image Image::decompressed() const {

	Image img = *this;
	img.decompress();
	return img;
}

Error Image::decompress() {

	if (format >= FORMAT_BC1 && format <= FORMAT_BC5)
		_decompress_bc(); //_image_decompress_bc(this);
	else if (format >= FORMAT_PVRTC2 && format <= FORMAT_PVRTC4_ALPHA && _image_decompress_pvrtc)
		_image_decompress_pvrtc(this);
	else if (format == FORMAT_ETC && _image_decompress_etc)
		_image_decompress_etc(this);
	else
		return ERR_UNAVAILABLE;
	return OK;
}

Error Image::compress(CompressMode p_mode) {

	switch (p_mode) {

		case COMPRESS_BC: {

			ERR_FAIL_COND_V(!_image_compress_bc_func, ERR_UNAVAILABLE);
			_image_compress_bc_func(this);
		} break;
		case COMPRESS_PVRTC2: {

			ERR_FAIL_COND_V(!_image_compress_pvrtc2_func, ERR_UNAVAILABLE);
			_image_compress_pvrtc2_func(this);
		} break;
		case COMPRESS_PVRTC4: {

			ERR_FAIL_COND_V(!_image_compress_pvrtc4_func, ERR_UNAVAILABLE);
			_image_compress_pvrtc4_func(this);
		} break;
		case COMPRESS_ETC: {

			ERR_FAIL_COND_V(!_image_compress_etc_func, ERR_UNAVAILABLE);
			_image_compress_etc_func(this);
		} break;
	}

	return OK;
}

Image Image::compressed(int p_mode) {

	Image ret = *this;
	ret.compress((Image::CompressMode)p_mode);

	return ret;
};

Image::Image(const char **p_xpm) {

	width = 0;
	height = 0;
	mipmaps = 0;
	format = FORMAT_GRAYSCALE;

	create(p_xpm);
}

Image::Image(int p_width, int p_height, bool p_use_mipmaps, Format p_format) {

	width = 0;
	height = 0;
	mipmaps = 0;
	format = FORMAT_GRAYSCALE;

	create(p_width, p_height, p_use_mipmaps, p_format);
}

Image::Image(int p_width, int p_height, int p_mipmaps, Format p_format, const DVector<uint8_t> &p_data) {

	width = 0;
	height = 0;
	mipmaps = 0;
	format = FORMAT_GRAYSCALE;

	create(p_width, p_height, p_mipmaps, p_format, p_data);
}

Image Image::brushed(const Image &p_src, const Image &p_brush, const Point2 &p_dest) const {

	Image img = *this;
	img.brush_transfer(p_src, p_brush, p_dest);
	return img;
}

Rect2 Image::get_used_rect() const {

	if (format == FORMAT_GRAYSCALE ||
			format == FORMAT_RGB ||
			format == FORMAT_INDEXED || format > FORMAT_INDEXED_ALPHA)
		return Rect2(Point2(), Size2(width, height));

	int len = data.size();

	if (len == 0)
		return Rect2();

	int data_size = len;
	DVector<uint8_t>::Read r = data.read();
	const unsigned char *rptr = r.ptr();

	int minx = 0xFFFFFF, miny = 0xFFFFFFF;
	int maxx = -1, maxy = -1;
	for (int i = 0; i < width; i++) {
		for (int j = 0; j < height; j++) {

			bool opaque = _get_pixel(i, j, rptr, data_size).a > 2;
			if (!opaque)
				continue;
			if (i > maxx)
				maxx = i;
			if (j > maxy)
				maxy = j;
			if (i < minx)
				minx = i;
			if (j < miny)
				miny = j;
		}
	}

	if (maxx == -1)
		return Rect2();
	else
		return Rect2(minx, miny, maxx - minx + 1, maxy - miny + 1);
}

Image Image::get_rect(const Rect2 &p_area) const {

	Image img(p_area.size.x, p_area.size.y, mipmaps, format);
	img.blit_rect(*this, p_area, Point2(0, 0));

	return img;
};

void Image::brush_transfer(const Image &p_src, const Image &p_brush, const Point2 &p_dest) {

	ERR_FAIL_COND(width != p_src.width || height != p_src.height);

	int dst_data_size = data.size();
	DVector<uint8_t>::Write wp = data.write();
	unsigned char *dst_data_ptr = wp.ptr();

	int src_data_size = p_src.data.size();
	DVector<uint8_t>::Read rp = p_src.data.read();
	const unsigned char *src_data_ptr = rp.ptr();

	int brush_data_size = p_brush.data.size();
	DVector<uint8_t>::Read bp = p_brush.data.read();
	const unsigned char *src_brush_ptr = bp.ptr();

	int bw = p_brush.get_width();
	int bh = p_brush.get_height();
	int dx = p_dest.x;
	int dy = p_dest.y;

	for (int i = dy; i < dy + bh; i++) {

		if (i < 0 || i >= height)
			continue;
		for (int j = dx; j < dx + bw; j++) {

			if (j < 0 || j >= width)
				continue;

			BColor src = p_src._get_pixel(j, i, src_data_ptr, src_data_size);
			BColor dst = _get_pixel(j, i, dst_data_ptr, dst_data_size);
			BColor brush = p_brush._get_pixel(j - dx, i - dy, src_brush_ptr, brush_data_size);
			uint32_t mult = brush.r;
			dst.r = dst.r + (((int32_t(src.r) - int32_t(dst.r)) * mult) >> 8);
			dst.g = dst.g + (((int32_t(src.g) - int32_t(dst.g)) * mult) >> 8);
			dst.b = dst.b + (((int32_t(src.b) - int32_t(dst.b)) * mult) >> 8);
			dst.a = dst.a + (((int32_t(src.a) - int32_t(dst.a)) * mult) >> 8);
			_put_pixel(j, i, dst, dst_data_ptr);
		}
	}
}

void Image::blit_rect(const Image &p_src, const Rect2 &p_src_rect, const Point2 &p_dest) {

	int dsize = data.size();
	int srcdsize = p_src.data.size();
	ERR_FAIL_COND(dsize == 0);
	ERR_FAIL_COND(srcdsize == 0);

	Rect2 rrect = Rect2(0, 0, p_src.width, p_src.height).clip(p_src_rect);

	DVector<uint8_t>::Write wp = data.write();
	unsigned char *dst_data_ptr = wp.ptr();

	DVector<uint8_t>::Read rp = p_src.data.read();
	const unsigned char *src_data_ptr = rp.ptr();

	if ((format == FORMAT_INDEXED || format == FORMAT_INDEXED_ALPHA) && (p_src.format == FORMAT_INDEXED || p_src.format == FORMAT_INDEXED_ALPHA)) {

		Point2i desti(p_dest.x, p_dest.y);
		Point2i srci(rrect.pos.x, rrect.pos.y);

		for (int i = 0; i < rrect.size.y; i++) {

			if (i < 0 || i >= height)
				continue;
			for (int j = 0; j < rrect.size.x; j++) {

				if (j < 0 || j >= width)
					continue;

				dst_data_ptr[width * (desti.y + i) + desti.x + j] = src_data_ptr[p_src.width * (srci.y + i) + srci.x + j];
			}
		}

	} else {

		for (int i = 0; i < rrect.size.y; i++) {

			if (i < 0 || i >= height)
				continue;
			for (int j = 0; j < rrect.size.x; j++) {

				if (j < 0 || j >= width)
					continue;

				_put_pixel(p_dest.x + j, p_dest.y + i, p_src._get_pixel(rrect.pos.x + j, rrect.pos.y + i, src_data_ptr, srcdsize), dst_data_ptr);
			}
		}
	}
}

Image (*Image::_png_mem_loader_func)(const uint8_t *, int) = NULL;
Image (*Image::_jpg_mem_loader_func)(const uint8_t *, int) = NULL;

void (*Image::_image_compress_bc_func)(Image *) = NULL;
void (*Image::_image_compress_pvrtc2_func)(Image *) = NULL;
void (*Image::_image_compress_pvrtc4_func)(Image *) = NULL;
void (*Image::_image_compress_etc_func)(Image *) = NULL;
void (*Image::_image_decompress_pvrtc)(Image *) = NULL;
void (*Image::_image_decompress_bc)(Image *) = NULL;
void (*Image::_image_decompress_etc)(Image *) = NULL;

DVector<uint8_t> (*Image::lossy_packer)(const Image &, float) = NULL;
Image (*Image::lossy_unpacker)(const DVector<uint8_t> &) = NULL;
DVector<uint8_t> (*Image::lossless_packer)(const Image &) = NULL;
Image (*Image::lossless_unpacker)(const DVector<uint8_t> &) = NULL;

void Image::set_compress_bc_func(void (*p_compress_func)(Image *)) {

	_image_compress_bc_func = p_compress_func;
}

void Image::normalmap_to_xy() {

	convert(Image::FORMAT_RGBA);

	{
		int len = data.size() / 4;
		DVector<uint8_t>::Write wp = data.write();
		unsigned char *data_ptr = wp.ptr();

		for (int i = 0; i < len; i++) {

			data_ptr[(i << 2) + 3] = data_ptr[(i << 2) + 0]; //x to w
			data_ptr[(i << 2) + 0] = data_ptr[(i << 2) + 1]; //y to xz
			data_ptr[(i << 2) + 2] = data_ptr[(i << 2) + 1];
		}
	}

	convert(Image::FORMAT_GRAYSCALE_ALPHA);
}

void Image::srgb_to_linear() {

	if (data.size() == 0)
		return;

	static const uint8_t srgb2lin[256] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 8, 8, 8, 9, 9, 9, 10, 10, 10, 11, 11, 11, 12, 12, 13, 13, 13, 14, 14, 15, 15, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 22, 22, 23, 23, 24, 24, 25, 26, 26, 27, 27, 28, 29, 29, 30, 31, 31, 32, 33, 33, 34, 35, 36, 36, 37, 38, 38, 39, 40, 41, 42, 42, 43, 44, 45, 46, 47, 47, 48, 49, 50, 51, 52, 53, 54, 55, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 70, 71, 72, 73, 74, 75, 76, 77, 78, 80, 81, 82, 83, 84, 85, 87, 88, 89, 90, 92, 93, 94, 95, 97, 98, 99, 101, 102, 103, 105, 106, 107, 109, 110, 112, 113, 114, 116, 117, 119, 120, 122, 123, 125, 126, 128, 129, 131, 132, 134, 135, 137, 139, 140, 142, 144, 145, 147, 148, 150, 152, 153, 155, 157, 159, 160, 162, 164, 166, 167, 169, 171, 173, 175, 176, 178, 180, 182, 184, 186, 188, 190, 192, 193, 195, 197, 199, 201, 203, 205, 207, 209, 211, 213, 215, 218, 220, 222, 224, 226, 228, 230, 232, 235, 237, 239, 241, 243, 245, 248, 250, 252 };

	ERR_FAIL_COND(format != FORMAT_RGB && format != FORMAT_RGBA);

	if (format == FORMAT_RGBA) {

		int len = data.size() / 4;
		DVector<uint8_t>::Write wp = data.write();
		unsigned char *data_ptr = wp.ptr();

		for (int i = 0; i < len; i++) {

			data_ptr[(i << 2) + 0] = srgb2lin[data_ptr[(i << 2) + 0]];
			data_ptr[(i << 2) + 1] = srgb2lin[data_ptr[(i << 2) + 1]];
			data_ptr[(i << 2) + 2] = srgb2lin[data_ptr[(i << 2) + 2]];
		}

	} else if (format == FORMAT_RGB) {

		int len = data.size() / 3;
		DVector<uint8_t>::Write wp = data.write();
		unsigned char *data_ptr = wp.ptr();

		for (int i = 0; i < len; i++) {

			data_ptr[(i * 3) + 0] = srgb2lin[data_ptr[(i * 3) + 0]];
			data_ptr[(i * 3) + 1] = srgb2lin[data_ptr[(i * 3) + 1]];
			data_ptr[(i * 3) + 2] = srgb2lin[data_ptr[(i * 3) + 2]];
		}
	}
}

void Image::premultiply_alpha() {

	if (data.size() == 0)
		return;

	if (format != FORMAT_RGBA)
		return; //not needed

	DVector<uint8_t>::Write wp = data.write();
	unsigned char *data_ptr = wp.ptr();

	for (int i = 0; i < height; i++) {
		for (int j = 0; j < width; j++) {

			BColor bc = _get_pixel(j, i, data_ptr, 0);
			bc.r = (int(bc.r) * int(bc.a)) >> 8;
			bc.g = (int(bc.g) * int(bc.a)) >> 8;
			bc.b = (int(bc.b) * int(bc.a)) >> 8;
			_put_pixel(j, i, bc, data_ptr);
		}
	}
}

void Image::fix_alpha_edges() {

	if (data.size() == 0)
		return;

	if (format != FORMAT_RGBA)
		return; //not needed

	DVector<uint8_t> dcopy = data;
	DVector<uint8_t>::Read rp = data.read();
	const uint8_t *rptr = rp.ptr();

	DVector<uint8_t>::Write wp = data.write();
	unsigned char *data_ptr = wp.ptr();

	const int max_radius = 4;
	const int alpha_treshold = 20;
	const int max_dist = 0x7FFFFFFF;

	for (int i = 0; i < height; i++) {
		for (int j = 0; j < width; j++) {

			BColor bc = _get_pixel(j, i, rptr, 0);
			if (bc.a >= alpha_treshold)
				continue;

			int closest_dist = max_dist;
			BColor closest_color;
			closest_color.a = bc.a;
			int from_x = MAX(0, j - max_radius);
			int to_x = MIN(width - 1, j + max_radius);
			int from_y = MAX(0, i - max_radius);
			int to_y = MIN(height - 1, i + max_radius);

			for (int k = from_y; k <= to_y; k++) {
				for (int l = from_x; l <= to_x; l++) {

					int dy = i - k;
					int dx = j - l;
					int dist = dy * dy + dx * dx;
					if (dist >= closest_dist)
						continue;

					const uint8_t *rp = &rptr[(k * width + l) << 2];

					if (rp[3] < alpha_treshold)
						continue;

					closest_dist = dist;
					closest_color.r = rp[0];
					closest_color.g = rp[1];
					closest_color.b = rp[2];
				}
			}

			if (closest_dist != max_dist)
				_put_pixel(j, i, closest_color, data_ptr);
		}
	}
}

String Image::get_format_name(Format p_format) {

	ERR_FAIL_INDEX_V(p_format, FORMAT_MAX, String());
	return format_names[p_format];
}

Image::Image(const uint8_t *p_mem_png_jpg, int p_len) {

	width = 0;
	height = 0;
	mipmaps = 0;
	format = FORMAT_GRAYSCALE;

	if (_png_mem_loader_func) {
		*this = _png_mem_loader_func(p_mem_png_jpg, p_len);
	}

	if (empty() && _jpg_mem_loader_func) {
		*this = _jpg_mem_loader_func(p_mem_png_jpg, p_len);
	}
}

Image::Image() {

	width = 0;
	height = 0;
	mipmaps = 0;
	format = FORMAT_GRAYSCALE;
}

Image::~Image() {
}