/* Copyright (C) 2003-2015 LiveCode Ltd.

This file is part of LiveCode.

LiveCode is free software; you can redistribute it and/or modify it under

the terms of the GNU General Public License v3 as published by the Free

Software Foundation.

LiveCode is distributed in the hope that it will be useful, but WITHOUT ANY

WARRANTY; without even the implied warranty of MERCHANTABILITY or

FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License

for more details.

You should have received a copy of the GNU General Public License

along with LiveCode. If not see <http://www.gnu.org/licenses/>. */

#include "graphics.h"

#include "graphics-internal.h"

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

static void MCGImageDestroy(MCGImageRef self)

{

if (self != NULL)

{

if (self -> bitmap != NULL)

{

self -> bitmap -> unlockPixels();

delete self -> bitmap;

}

MCMemoryDelete(self);

}

}

bool MCGImageCreateWithSkBitmap(const SkBitmap &p_bitmap, MCGImageRef &r_image)

{

bool t_success;

t_success = true;

__MCGImage *t_image;

t_image = nil;

if (t_success)

t_success = MCMemoryNew(t_image);

SkBitmap *t_bitmap;

t_bitmap = nil;

if (t_success)

{

t_bitmap = new (nothrow) SkBitmap(p_bitmap);

t_success = nil != t_bitmap;

}

if (t_success)

{

t_bitmap -> lockPixels();

t_image -> bitmap = t_bitmap;

t_image -> is_valid = true;

t_image -> references = 1;

r_image = t_image;

}

else

{

if (t_bitmap != nil)

delete t_bitmap;

MCMemoryDelete(t_image);

}

return t_success;

}

bool MCGImageCreateWithRaster(const MCGRaster &p_raster, MCGPixelOwnershipType p_ownership, MCGImageRef &r_image)

{

bool t_success;

t_success = true;

__MCGImage *t_image;

t_image = nil;

SkBitmap t_bitmap;

if (t_success)

t_success = MCGRasterToSkBitmap(p_raster, p_ownership, t_bitmap);

if (t_success)

t_success = MCGImageCreateWithSkBitmap(t_bitmap, t_image);

if (t_success)

r_image = t_image;

else

MCMemoryDelete(t_image);

return t_success;

}

bool MCGImageCreateWithRasterAndRelease(const MCGRaster &p_raster, MCGImageRef &r_image)

{

return MCGImageCreateWithRaster(p_raster, kMCGPixelOwnershipTypeTake, r_image);

}

bool MCGImageCreateWithRasterNoCopy(const MCGRaster& p_raster, MCGImageRef& r_image)

{

return MCGImageCreateWithRaster(p_raster, kMCGPixelOwnershipTypeBorrow, r_image);

}

bool MCGImageCreateWithRaster(const MCGRaster& p_raster, MCGImageRef& r_image)

{

return MCGImageCreateWithRaster(p_raster, kMCGPixelOwnershipTypeCopy, r_image);

}

bool MCGImageGetRaster(MCGImageRef p_image, MCGRaster &r_raster)

{

if (p_image == nil)

return false;

__MCGImage *t_image = (__MCGImage*)p_image;

if (!t_image->is_valid || t_image->bitmap == nil)

return false;

// IM-2013-06-18: lock pixels here to force skia to update the pixel ptr

// from the bitmap's pixel ref

t_image->bitmap->lockPixels();

// IM-2014-05-20: [[ GraphicsPerformance ]] Use bitmap opaqueness when setting the raster format.

r_raster.format = MCGRasterFormatFromSkImageInfo(t_image->bitmap->info(), t_image->bitmap->isOpaque());

r_raster.width = t_image->bitmap->width();

r_raster.height = t_image->bitmap->height();

r_raster.pixels = t_image->bitmap->getPixels();

r_raster.stride =t_image->bitmap->rowBytes();

t_image->bitmap->unlockPixels();

return true;

}

bool MCGImageGetPixel(MCGImageRef p_image, uint32_t x, uint32_t y, uint32_t &r_pixel)

{

MCGRaster t_raster;

if (!MCGImageGetRaster(p_image, t_raster) || x >= t_raster.width || y >= t_raster.height)

return false;

uint8_t* t_row_ptr;

t_row_ptr = ((uint8_t*)t_raster.pixels) + y * t_raster.stride;

if (t_raster.format == kMCGRasterFormat_A)

r_pixel = t_row_ptr[x];

else

r_pixel = ((uint32_t*)t_row_ptr)[x];

return true;

}

bool MCGImageCreateWithData(const void *p_bytes, uindex_t p_byte_count, MCGImageRef& r_image)

{

// TODO: Implement

return false;

}

bool MCGImageCreateWithFilename(const char *p_filename, MCGImageRef& r_image)

{

// TODO: Implement

return false;

}

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

MCGImageRef MCGImageRetain(MCGImageRef self)

{

if (self != NULL)

sk_atomic_inc((int32_t *)&self -> references);

return self;

}

void MCGImageRelease(MCGImageRef self)

{

if (self != NULL)

{

if (sk_atomic_dec((int32_t *)&self -> references) == 1)

MCGImageDestroy(self);

}

}

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

bool MCGImageIsValid(MCGImageRef self)

{

return self != NULL && self -> is_valid;

}

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

int32_t MCGImageGetWidth(MCGImageRef self)

{

return self -> bitmap -> width();

}

int32_t MCGImageGetHeight(MCGImageRef self)

{

return self -> bitmap -> height();

}

MCGSize MCGImageGetSize(MCGImageRef self)

{

MCGSize t_size;

t_size . width = 0;

t_size . height = 0;

if (!MCGImageIsValid(self))

return t_size;

t_size . width = (MCGFloat) self -> bitmap -> width();

t_size . height = (MCGFloat) self -> bitmap -> height();

return t_size;

}

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

bool MCGImageIsOpaque(MCGImageRef self)

{

return self != nil && self -> bitmap -> isOpaque();

}

bool MCGImageHasPartialTransparency(MCGImageRef self)

{

if (self == nil)

return false;

if (self->bitmap->isOpaque())

return false;

MCGRaster t_raster;

if (!MCGImageGetRaster(self, t_raster))

return false;

if (t_raster.format == kMCGRasterFormat_A)

return true;

uint8_t *t_row_ptr;

t_row_ptr = (uint8_t*)t_raster.pixels;

for (uint32_t y = 0; y < t_raster.height; y++)

{

uint32_t *t_pixel_ptr;

t_pixel_ptr = (uint32_t*)t_row_ptr;

for (uint32_t x = 0; x < t_raster.width; x++)

{

uint8_t t_alpha;

t_alpha = MCGPixelGetNativeAlpha(*t_pixel_ptr++);

if (t_alpha > 0 && t_alpha < 255)

return true;

}

t_row_ptr += t_raster.stride;

}

return false;

}

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