#include "ICNSLoader.h"
#include "BaseTranslator.h"
static int compareTypes(const void *a, const void *b)
{
icns_type_t **typeItemA = (icns_type_t**)a;
icns_type_t **typeItemB = (icns_type_t**)b;
icns_icon_info_t imageInfoA = icns_get_image_info_for_type(**typeItemA);
icns_icon_info_t imageInfoB = icns_get_image_info_for_type(**typeItemB);
return imageInfoB.iconWidth - imageInfoA.iconWidth;
}
icns_type_t
ICNSFormat(float width, float height, color_space colors)
{
int imageWidth = (int)ceil(width);
int imageHeight = (int)ceil(height);
if (imageWidth != imageHeight)
return ICNS_NULL_TYPE;
if (colors != B_RGB32 && colors != B_RGBA32)
return ICNS_NULL_TYPE;
switch (imageWidth) {
case 16:
return ICNS_16x16_32BIT_DATA;
case 32:
return ICNS_32x32_32BIT_DATA;
case 48:
return ICNS_48x48_32BIT_DATA;
case 128:
return ICNS_128X128_32BIT_DATA;
case 256:
return ICNS_256x256_32BIT_ARGB_DATA;
case 512:
return ICNS_512x512_32BIT_ARGB_DATA;
case 1024:
return ICNS_1024x1024_32BIT_ARGB_DATA;
}
return ICNS_NULL_TYPE;
}
ICNSLoader::ICNSLoader(BPositionIO *stream)
{
fLoaded = false;
fIconsCount = 0;
stream->Seek(0, SEEK_END);
fStreamSize = stream->Position();
stream->Seek(0, SEEK_SET);
if (fStreamSize <= 0)
return;
uint8* icnsDataBuffer = new uint8[fStreamSize];
size_t readedBytes = stream->Read(icnsDataBuffer,fStreamSize);
fIconFamily = NULL;
int status = icns_import_family_data(readedBytes, icnsDataBuffer,
&fIconFamily);
if (status != 0) {
delete[] icnsDataBuffer;
return;
}
icns_byte_t *dataPtr = (icns_byte_t*)fIconFamily;
off_t dataOffset = sizeof(icns_type_t) + sizeof(icns_size_t);
while ((dataOffset+8) < fIconFamily->resourceSize) {
icns_element_t iconElement;
icns_size_t iconDataSize;
memcpy(&iconElement, (dataPtr + dataOffset), 8);
iconDataSize = iconElement.elementSize - 8;
if (IS_SPUPPORTED_TYPE(iconElement.elementType)) {
icns_type_t* newTypeItem = new icns_type_t;
*newTypeItem = iconElement.elementType;
fFormatList.AddItem(newTypeItem);
fIconsCount++;
}
dataOffset += iconElement.elementSize;
}
fFormatList.SortItems(compareTypes);
delete[] icnsDataBuffer;
fLoaded = true;
}
ICNSLoader::~ICNSLoader()
{
if (fIconFamily != NULL)
free(fIconFamily);
icns_type_t* item;
for (int32 i = 0; (item = (icns_type_t*)fFormatList.ItemAt(i)) != NULL; i++)
delete item;
fFormatList.MakeEmpty();
}
bool
ICNSLoader::IsLoaded(void)
{
return fLoaded;
}
int
ICNSLoader::IconsCount(void)
{
return fIconsCount;
}
int
ICNSLoader::GetIcon(BPositionIO *target, int index)
{
if (index < 1 || index > fIconsCount || !fLoaded)
return B_NO_TRANSLATOR;
icns_image_t iconImage;
memset(&iconImage, 0, sizeof(icns_image_t));
icns_type_t typeItem = *((icns_type_t*)fFormatList.ItemAt(index - 1));
int status = icns_get_image32_with_mask_from_family(fIconFamily,
typeItem, &iconImage);
if (status != 0)
return B_NO_TRANSLATOR;
TranslatorBitmap bitsHeader;
bitsHeader.magic = B_TRANSLATOR_BITMAP;
bitsHeader.bounds.left = 0;
bitsHeader.bounds.top = 0;
bitsHeader.bounds.right = iconImage.imageWidth - 1;
bitsHeader.bounds.bottom = iconImage.imageHeight - 1;
bitsHeader.rowBytes = sizeof(uint32) * iconImage.imageWidth;
bitsHeader.colors = B_RGBA32;
bitsHeader.dataSize = bitsHeader.rowBytes * iconImage.imageHeight;
if (swap_data(B_UINT32_TYPE, &bitsHeader,
sizeof(TranslatorBitmap), B_SWAP_HOST_TO_BENDIAN) != B_OK) {
icns_free_image(&iconImage);
return B_NO_TRANSLATOR;
}
target->Write(&bitsHeader, sizeof(TranslatorBitmap));
uint8 *rowBuff = new uint8[iconImage.imageWidth * sizeof(uint32)];
for (uint32 i = 0; i < iconImage.imageHeight; i++) {
uint8 *rowData = iconImage.imageData
+ (i * iconImage.imageWidth * sizeof(uint32));
uint8 *rowBuffPtr = rowBuff;
for (uint32 j=0; j < iconImage.imageWidth; j++) {
rowBuffPtr[0] = rowData[2];
rowBuffPtr[1] = rowData[1];
rowBuffPtr[2] = rowData[0];
rowBuffPtr[3] = rowData[3];
rowBuffPtr += sizeof(uint32);
rowData += sizeof(uint32);
}
target->Write(rowBuff, iconImage.imageWidth * sizeof(uint32));
}
delete[] rowBuff;
icns_free_image(&iconImage);
return B_OK;
}
ICNSSaver::ICNSSaver(BPositionIO *stream, uint32 rowBytes, icns_type_t type)
{
fCreated = false;
icns_icon_info_t imageTypeInfo = icns_get_image_info_for_type(type);
int iconWidth = imageTypeInfo.iconWidth;
int iconHeight = imageTypeInfo.iconHeight;
int bpp = 32;
uint8 *bits = new uint8[iconWidth * iconHeight * sizeof(uint32)];
uint8 *rowPtr = bits;
for (int i = 0; i < iconHeight; i++) {
stream->Read(rowPtr, rowBytes);
uint8 *bytePtr = rowPtr;
for (int j=0; j < iconWidth; j++) {
uint8 temp = bytePtr[0];
bytePtr[0] = bytePtr[2];
bytePtr[2] = temp;
bytePtr += sizeof(uint32);
}
rowPtr += iconWidth * sizeof(uint32);
}
icns_create_family(&fIconFamily);
icns_image_t icnsImage;
icnsImage.imageWidth = iconWidth;
icnsImage.imageHeight = iconHeight;
icnsImage.imageChannels = 4;
icnsImage.imagePixelDepth = 8;
icnsImage.imageDataSize = iconWidth * iconHeight * 4;
icnsImage.imageData = bits;
icns_icon_info_t iconInfo;
iconInfo.isImage = 1;
iconInfo.iconWidth = icnsImage.imageWidth;
iconInfo.iconHeight = icnsImage.imageHeight;
iconInfo.iconBitDepth = bpp;
iconInfo.iconChannels = (bpp == 32 ? 4 : 1);
iconInfo.iconPixelDepth = bpp / iconInfo.iconChannels;
icns_type_t iconType = icns_get_type_from_image_info(iconInfo);
if (iconType == ICNS_NULL_TYPE) {
delete[] bits;
free(fIconFamily);
fIconFamily = NULL;
return;
}
icns_element_t *iconElement = NULL;
int icnsErr = icns_new_element_from_image(&icnsImage, iconType,
&iconElement);
if (iconElement != NULL) {
if (icnsErr == ICNS_STATUS_OK) {
icns_set_element_in_family(&fIconFamily, iconElement);
fCreated = true;
}
free(iconElement);
}
if (iconType != ICNS_1024x1024_32BIT_ARGB_DATA
&& iconType != ICNS_512x512_32BIT_ARGB_DATA
&& iconType != ICNS_256x256_32BIT_ARGB_DATA) {
icns_type_t maskType =
icns_get_mask_type_for_icon_type(iconType);
icns_image_t icnsMask;
icns_init_image_for_type(maskType, &icnsMask);
uint32 iconDataOffset = 0;
uint32 maskDataOffset = 0;
while (iconDataOffset < icnsImage.imageDataSize
&& maskDataOffset < icnsMask.imageDataSize) {
icnsMask.imageData[maskDataOffset] =
icnsImage.imageData[iconDataOffset + 3];
iconDataOffset += 4;
maskDataOffset += 1;
}
icns_element_t *maskElement = NULL;
icnsErr = icns_new_element_from_mask(&icnsMask, maskType,
&maskElement);
if (maskElement != NULL) {
if (icnsErr == ICNS_STATUS_OK) {
icns_set_element_in_family(&fIconFamily,
maskElement);
} else
fCreated = false;
free(maskElement);
}
icns_free_image(&icnsMask);
}
if (!fCreated) {
free(fIconFamily);
fIconFamily = NULL;
}
delete[] bits;
}
ICNSSaver::~ICNSSaver()
{
if (fIconFamily != NULL)
free(fIconFamily);
}
int
ICNSSaver::SaveData(BPositionIO *target)
{
icns_size_t dataSize;
icns_byte_t *dataPtrOut;
icns_export_family_data(fIconFamily, &dataSize, &dataPtrOut);
if (dataSize != 0 && dataPtrOut != NULL) {
if (target->Write(dataPtrOut, dataSize) == dataSize)
return B_OK;
}
return B_ERROR;
}
bool
ICNSSaver::IsCreated(void)
{
return fCreated;
}
