Merge branch 'master' into sam460ex

build/jam/HaikuImage

@@ -129,7 +129,7 @@ SYSTEM_ADD_ONS_TRANSLATORS = BMPTranslator EXRTranslator GIFTranslator
 	HVIFTranslator ICOTranslator JPEGTranslator JPEG2000Translator
 	PCXTranslator PNGTranslator PPMTranslator
 	RAWTranslator RTFTranslator SGITranslator STXTTranslator TGATranslator
-	TIFFTranslator WebPTranslator WonderBrushTranslator
+	TIFFTranslator WebPTranslator WonderBrushTranslator ICNSTranslator
 ;
 SYSTEM_ADD_ONS_LOCALE_CATALOGS = <catalog-addon>plaintext ;
 SYSTEM_ADD_ONS_MEDIA = cortex_audioadapter.media_addon
@@ -363,7 +363,7 @@ AddSymlinkToHaikuHybridImage system lib : $(HAIKU_JPEG_CURRENT_LINK)
 AddSymlinkToHaikuHybridImage system lib : $(HAIKU_ZLIB_CURRENT_LIB:BS)
 	: $(HAIKU_ZLIB_CURRENT_LINK) : : true ;
 AddSymlinkToHaikuHybridImage system lib : $(HAIKU_ZLIB_CURRENT_LINK)
-	: libzlib.so : : true ;
+	: libz.so : : true ;
 
 # servers
 AddFilesToHaikuImage system servers : $(SYSTEM_SERVERS) ;

src/add-ons/translators/Jamfile

@@ -20,3 +20,4 @@ SubInclude HAIKU_TOP src add-ons translators tga ;
 SubInclude HAIKU_TOP src add-ons translators tiff ;
 SubInclude HAIKU_TOP src add-ons translators webp ;
 SubInclude HAIKU_TOP src add-ons translators wonderbrush ;
+SubInclude HAIKU_TOP src add-ons translators icns ;

src/add-ons/translators/icns/ConfigView.cpp

@@ -0,0 +1,103 @@
+/*
+ * Copyright 2012, Gerasim Troeglazov, [email protected]. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */ 
+
+#include "ConfigView.h"
+#include "ICNSTranslator.h"
+
+#include <StringView.h>
+#include <SpaceLayoutItem.h>
+#include <ControlLook.h>
+
+#include <stdio.h>
+
+extern "C" {
+#include <openjpeg.h>
+};
+
+
+ConfigView::ConfigView(TranslatorSettings *settings)
+	: BGroupView("ICNSTranslator Settings", B_VERTICAL, 0)
+{
+	fSettings = settings;
+	BAlignment leftAlignment(B_ALIGN_LEFT, B_ALIGN_VERTICAL_UNSET);
+
+	BStringView *stringView = new BStringView("title", "Apple icon translator");
+	stringView->SetFont(be_bold_font);
+	stringView->SetExplicitAlignment(leftAlignment);
+	AddChild(stringView);
+
+	float spacing = be_control_look->DefaultItemSpacing();
+	AddChild(BSpaceLayoutItem::CreateVerticalStrut(spacing));
+
+	char version[256];
+	sprintf(version, "Version %d.%d.%d, %s",
+		int(B_TRANSLATION_MAJOR_VERSION(ICNS_TRANSLATOR_VERSION)),
+		int(B_TRANSLATION_MINOR_VERSION(ICNS_TRANSLATOR_VERSION)),
+		int(B_TRANSLATION_REVISION_VERSION(ICNS_TRANSLATOR_VERSION)),
+		__DATE__);
+	stringView = new BStringView("version", version);
+	stringView->SetExplicitAlignment(leftAlignment);
+	AddChild(stringView);
+
+	stringView = new BStringView("copyright",
+		B_UTF8_COPYRIGHT "2005-2006 Haiku Inc.");
+	stringView->SetExplicitAlignment(leftAlignment);
+	AddChild(stringView);
+
+	stringView = new BStringView("my_copyright",
+		B_UTF8_COPYRIGHT "2012 Gerasim Troeglazov <[email protected]>.");
+	stringView->SetExplicitAlignment(leftAlignment);
+	AddChild(stringView);
+
+	AddChild(BSpaceLayoutItem::CreateVerticalStrut(spacing));
+
+	stringView = new BStringView("support_sizes",
+		"Valid sizes: 16, 32, 48, 128, 256, 512, 1024");
+	stringView->SetExplicitAlignment(leftAlignment);
+	AddChild(stringView);
+
+	stringView = new BStringView("support_colors",
+		"Valid colors: RGB32, RGBA32");
+	stringView->SetExplicitAlignment(leftAlignment);
+	AddChild(stringView);	
+
+	AddChild(BSpaceLayoutItem::CreateVerticalStrut(spacing));
+
+	BString copyrightText;
+	copyrightText << "libicns v0.8.1\n"
+		<< B_UTF8_COPYRIGHT "2001-2012 Mathew Eis <[email protected]>\n\n"
+		<< "OpenJPEG " << opj_version() << "\n"
+		<< B_UTF8_COPYRIGHT "2002-2012, Communications and Remote Sensing "
+		<< "Laboratory, Universite catholique de Louvain (UCL), Belgium";
+	
+	fCopyrightView = new BTextView("CopyrightLibs");
+	fCopyrightView->SetExplicitAlignment(leftAlignment);
+	fCopyrightView->MakeEditable(false);
+	fCopyrightView->MakeResizable(true);
+	fCopyrightView->SetWordWrap(true);
+	fCopyrightView->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
+	fCopyrightView->SetText(copyrightText.String());
+	fCopyrightView->SetExplicitMinSize(BSize(300,200));
+
+	BFont font;
+	font.SetSize(font.Size() * 0.9);
+	fCopyrightView->SetFontAndColor(&font, B_FONT_SIZE, NULL);
+	AddChild(fCopyrightView);
+
+	fCopyrightView->SetExplicitAlignment(leftAlignment);
+	
+	AddChild(BSpaceLayoutItem::CreateGlue());
+	GroupLayout()->SetInsets(B_USE_DEFAULT_SPACING, B_USE_DEFAULT_SPACING, 
+		B_USE_DEFAULT_SPACING, B_USE_DEFAULT_SPACING);
+
+	SetExplicitPreferredSize(GroupLayout()->MinSize());		
+}
+
+
+ConfigView::~ConfigView()
+{
+	fSettings->Release();
+}
+

src/add-ons/translators/icns/ConfigView.h

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2012, Gerasim Troeglazov, [email protected]. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */ 
+
+#ifndef CONFIG_VIEW_H
+#define CONFIG_VIEW_H
+
+#include "TranslatorSettings.h"
+
+#include <View.h>
+#include <TextView.h>
+#include <String.h>
+#include <GroupView.h>
+
+
+class ConfigView : public BGroupView {
+	public:
+		ConfigView(TranslatorSettings *settings);
+		virtual ~ConfigView();
+
+	private:
+		BTextView*			fCopyrightView;	
+		TranslatorSettings *fSettings;
+};
+
+#endif	// CONFIG_VIEW_H

src/add-ons/translators/icns/ICNSLoader.cpp

@@ -0,0 +1,318 @@
+/*
+ * Copyright 2012, Gerasim Troeglazov, [email protected]. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */ 
+
+#include "ICNSLoader.h"
+#include "BaseTranslator.h"
+
+
+static int compareTypes(const void *a, const void *b)
+{
+	icns_type_t typeItemA = *((icns_type_t*)(*((icns_type_t*)a)));
+	icns_type_t typeItemB = *((icns_type_t*)(*((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;
+	
+	//other colors depth not supported now
+	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.iconWidth;
+	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;
+}

src/add-ons/translators/icns/ICNSLoader.h

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2012, Gerasim Troeglazov, [email protected]. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+
+#ifndef ICNS_LOADER_H
+#define ICNS_LOADER_H
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <Translator.h>
+#include <TranslatorFormats.h>
+#include <TranslationDefs.h>
+#include <GraphicsDefs.h>
+#include <InterfaceDefs.h>
+#include <DataIO.h>
+#include <File.h>
+#include <ByteOrder.h>
+#include <List.h>
+
+extern "C" {
+#include "icns.h"
+}
+
+#define IS_SPUPPORTED_TYPE(type) ((type) == ICNS_1024x1024_32BIT_ARGB_DATA || \
+								  (type) == ICNS_512x512_32BIT_ARGB_DATA || \
+								  (type) == ICNS_256x256_32BIT_ARGB_DATA || \
+								  (type) == ICNS_128X128_32BIT_DATA || \
+								  (type) == ICNS_48x48_32BIT_DATA || \
+								  (type) == ICNS_32x32_32BIT_DATA || \
+								  (type) == ICNS_16x16_32BIT_DATA)
+
+icns_type_t ICNSFormat(float width, float height, color_space colors);
+
+class ICNSLoader {
+public:
+					ICNSLoader(BPositionIO *stream);
+					~ICNSLoader();
+		
+	int				IconsCount(void);
+	int 			GetIcon(BPositionIO *target, int index);
+	bool			IsLoaded(void);
+private:	
+	icns_family_t*	fIconFamily;
+	int				fIconsCount;
+	size_t			fStreamSize;
+	BList			fFormatList;
+	bool			fLoaded;	
+};
+
+class ICNSSaver {
+public:
+					ICNSSaver(BPositionIO *stream, uint32 rowBytes,
+						icns_type_t type);
+					~ICNSSaver();
+		
+	int 			SaveData(BPositionIO *target);
+	bool			IsCreated(void);
+private:	
+	icns_family_t*	fIconFamily;
+	bool			fCreated;
+	
+};
+
+
+#endif	/* ICNS_LOADER_H */

src/add-ons/translators/icns/ICNSTranslator.cpp

@@ -0,0 +1,237 @@
+/*
+ * Copyright 2005, Axel Dörfler, [email protected]. All rights reserved.
+ * Copyright 2012, Gerasim Troeglazov, [email protected]. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+
+#include "ICNSTranslator.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "ConfigView.h"
+#include "ICNSLoader.h"
+
+extern "C" {
+#include "icns.h"
+}
+
+const char *kDocumentCount = "/documentCount";
+const char *kDocumentIndex = "/documentIndex";
+
+#define kICNSMimeType "image/icns"
+#define kICNSName "Apple Icon"
+
+// The input formats that this translator supports.
+static const translation_format sInputFormats[] = {
+	{
+		ICNS_IMAGE_FORMAT,
+		B_TRANSLATOR_BITMAP,
+		ICNS_IN_QUALITY,
+		ICNS_IN_CAPABILITY,
+		kICNSMimeType,
+		kICNSName
+	},
+	{
+		B_TRANSLATOR_BITMAP,
+		B_TRANSLATOR_BITMAP,
+		BITS_IN_QUALITY,
+		BITS_IN_CAPABILITY,
+		"image/x-be-bitmap",
+		"Be Bitmap Format (ICNSTranslator)"
+	},
+};
+
+// The output formats that this translator supports.
+static const translation_format sOutputFormats[] = {
+	{
+		ICNS_IMAGE_FORMAT,
+		B_TRANSLATOR_BITMAP,
+		ICNS_OUT_QUALITY,
+		ICNS_OUT_CAPABILITY,
+		kICNSMimeType,
+		kICNSName
+	},
+	{
+		B_TRANSLATOR_BITMAP,
+		B_TRANSLATOR_BITMAP,
+		BITS_OUT_QUALITY,
+		BITS_OUT_CAPABILITY,
+		"image/x-be-bitmap",
+		"Be Bitmap Format (ICNSTranslator)"
+	},
+};
+
+// Default settings for the Translator
+static const TranSetting sDefaultSettings[] = {
+	{B_TRANSLATOR_EXT_HEADER_ONLY, TRAN_SETTING_BOOL, false},
+	{B_TRANSLATOR_EXT_DATA_ONLY, TRAN_SETTING_BOOL, false}
+};
+
+const uint32 kNumInputFormats = sizeof(sInputFormats)
+	/ sizeof(translation_format);
+const uint32 kNumOutputFormats = sizeof(sOutputFormats)
+	/ sizeof(translation_format);
+const uint32 kNumDefaultSettings = sizeof(sDefaultSettings)
+	/ sizeof(TranSetting);
+
+
+ICNSTranslator::ICNSTranslator()
+	: BaseTranslator("Apple icons", 
+		"Apple icon translator",
+		ICNS_TRANSLATOR_VERSION,
+		sInputFormats, kNumInputFormats,
+		sOutputFormats, kNumOutputFormats,
+		"ICNSTranslator",
+		sDefaultSettings, kNumDefaultSettings,
+		B_TRANSLATOR_BITMAP, ICNS_IMAGE_FORMAT)
+{
+}
+
+
+ICNSTranslator::~ICNSTranslator()
+{
+}
+
+
+status_t
+ICNSTranslator::DerivedIdentify(BPositionIO *stream,
+	const translation_format *format, BMessage *ioExtension,
+	translator_info *info, uint32 outType)
+{
+	if (!outType)
+		outType = B_TRANSLATOR_BITMAP;
+	if (outType != B_TRANSLATOR_BITMAP && outType != ICNS_IMAGE_FORMAT)
+		return B_NO_TRANSLATOR;
+
+	uint32 signatureData;
+	ssize_t signatureSize = 4;
+	if (stream->Read(&signatureData, signatureSize) != signatureSize)
+		return B_IO_ERROR;
+			
+	const uint32 kICNSMagic = B_HOST_TO_BENDIAN_INT32('icns');
+	
+	if (signatureData != kICNSMagic)
+		return B_ILLEGAL_DATA;	
+		
+
+	ICNSLoader icnsFile(stream);
+	if(!icnsFile.IsLoaded() || icnsFile.IconsCount() <= 0)
+		return B_ILLEGAL_DATA;
+
+	int32 documentCount = icnsFile.IconsCount();
+	int32 documentIndex = 1;
+	
+	if (ioExtension) {
+		if (ioExtension->FindInt32(DOCUMENT_INDEX, &documentIndex) != B_OK)
+			documentIndex = 1;
+		if (documentIndex < 1 || documentIndex > documentCount)
+			return B_NO_TRANSLATOR;
+	}	
+	
+	if (ioExtension) {
+		ioExtension->RemoveName(DOCUMENT_COUNT);
+		ioExtension->AddInt32(DOCUMENT_COUNT, documentCount);
+	}	
+		
+	info->type = ICNS_IMAGE_FORMAT;
+	info->group = B_TRANSLATOR_BITMAP;
+	info->quality = ICNS_IN_QUALITY;
+	info->capability = ICNS_IN_CAPABILITY;
+	BString iconName("Apple icon");
+	if (documentCount > 1)
+		iconName << " #" << documentIndex;
+	snprintf(info->name, sizeof(info->name), iconName.String());
+	strcpy(info->MIME, kICNSMimeType);
+
+	return B_OK;
+}
+
+
+status_t
+ICNSTranslator::DerivedTranslate(BPositionIO *source,
+	const translator_info *info, BMessage *ioExtension,
+	uint32 outType, BPositionIO *target, int32 baseType)
+{
+	if (!outType)
+		outType = B_TRANSLATOR_BITMAP;
+	if (outType != B_TRANSLATOR_BITMAP && outType != ICNS_IMAGE_FORMAT)
+		return B_NO_TRANSLATOR;
+
+	switch (baseType) {
+		case 1:
+		{
+			TranslatorBitmap bitsHeader;		
+			status_t result;		
+			result = identify_bits_header(source, NULL, &bitsHeader);
+			if (result != B_OK)
+				return B_NO_TRANSLATOR;
+							
+			icns_type_t type = ICNSFormat(bitsHeader.bounds.Width() + 1,
+				bitsHeader.bounds.Height() + 1, bitsHeader.colors);				
+			if (type == ICNS_NULL_TYPE)
+				return B_NO_TRANSLATOR;
+			
+			if (outType == ICNS_IMAGE_FORMAT) {
+				ICNSSaver icnsFile(source, bitsHeader.rowBytes, type);
+				if (icnsFile.IsCreated())
+					return icnsFile.SaveData(target);
+			}
+			
+			return B_NO_TRANSLATOR;
+		}
+
+		case 0:
+		{								
+			if (outType != B_TRANSLATOR_BITMAP)
+				return B_NO_TRANSLATOR;			
+							
+			ICNSLoader icnsFile(source);
+			if (!icnsFile.IsLoaded() || icnsFile.IconsCount() <= 0)
+				return B_NO_TRANSLATOR;
+
+			int32 documentIndex = 1;
+			
+			if (ioExtension) {
+				if (ioExtension->FindInt32(DOCUMENT_INDEX, &documentIndex) != B_OK)
+					documentIndex = 1;
+			}
+								
+			return icnsFile.GetIcon(target, documentIndex);
+		}
+
+		default:
+			return B_NO_TRANSLATOR;
+	}
+}
+
+
+status_t
+ICNSTranslator::DerivedCanHandleImageSize(float width, float height) const
+{
+	if (ICNSFormat(width, height, B_RGBA32) == ICNS_NULL_TYPE)
+		return B_NO_TRANSLATOR;
+	return B_OK;
+}
+
+
+BView *
+ICNSTranslator::NewConfigView(TranslatorSettings *settings)
+{
+	return new ConfigView(settings);
+}
+
+
+//	#pragma mark -
+
+
+BTranslator *
+make_nth_translator(int32 n, image_id you, uint32 flags, ...)
+{
+	if (n != 0)
+		return NULL;
+
+	return new ICNSTranslator();
+}
+

src/add-ons/translators/icns/ICNSTranslator.h

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2005, Axel Dörfler, [email protected]. All rights reserved.
+ * Copyright 2012, Gerasim Troeglazov, [email protected]. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+
+#ifndef ICNS_TRANSLATOR_H
+#define ICNS_TRANSLATOR_H
+
+
+#include "BaseTranslator.h"
+
+#include <Translator.h>
+#include <TranslatorFormats.h>
+#include <TranslationDefs.h>
+#include <GraphicsDefs.h>
+#include <InterfaceDefs.h>
+#include <DataIO.h>
+#include <File.h>
+#include <ByteOrder.h>
+
+#define DOCUMENT_COUNT "/documentCount"
+#define DOCUMENT_INDEX "/documentIndex"
+
+#define ICNS_TRANSLATOR_VERSION B_TRANSLATION_MAKE_VERSION(1, 0, 0)
+#define ICNS_IMAGE_FORMAT	'ICNS'
+
+#define ICNS_IN_QUALITY		0.5
+#define ICNS_IN_CAPABILITY	0.5
+#define BITS_IN_QUALITY		1
+#define BITS_IN_CAPABILITY	1
+
+#define ICNS_OUT_QUALITY	0.8
+#define ICNS_OUT_CAPABILITY	0.8
+#define BITS_OUT_QUALITY	1
+#define BITS_OUT_CAPABILITY	0.9
+
+
+class ICNSTranslator : public BaseTranslator {
+	public:
+		ICNSTranslator();
+
+		virtual status_t DerivedIdentify(BPositionIO *inSource,
+			const translation_format *inFormat, BMessage *ioExtension,
+			translator_info *outInfo, uint32 outType);
+
+		virtual status_t DerivedTranslate(BPositionIO *inSource,
+			const translator_info *inInfo, BMessage *ioExtension,
+			uint32 outType, BPositionIO *outDestination, int32 baseType);
+
+		virtual status_t DerivedCanHandleImageSize(float width,
+			float height) const;
+
+		virtual BView *NewConfigView(TranslatorSettings *settings);	
+
+	protected:
+		virtual ~ICNSTranslator();
+};
+
+// Extensions that ShowImage supports
+extern const char *kDocumentCount;
+extern const char *kDocumentIndex;
+
+#endif	/* ICNS_TRANSLATOR_H */

src/add-ons/translators/icns/ICNSTranslator.rdef

@@ -0,0 +1,15 @@
+/*
+ * ICNSTranslator.rdef
+ */
+
+resource app_signature "application/x-vnd.Haiku-ICNSTranslator";
+
+resource app_version {
+	major  = 1,
+	middle = 0,
+	minor  = 0,
+	variety = 0,
+	internal = 0,
+	short_info = "1.0.0",
+	long_info = "Haiku ICNSTranslator Add-Ons."
+};

src/add-ons/translators/icns/Jamfile

@@ -0,0 +1,90 @@
+SubDir HAIKU_TOP src add-ons translators icns ;
+
+SetSubDirSupportedPlatformsBeOSCompatible ;
+
+UseHeaders $(HAIKU_LIBPNG_HEADERS) : true ;
+
+SubDirSysHdrs [ FDirName $(SUBDIR) openjpeg ] ;
+SubDirSysHdrs [ FDirName $(SUBDIR) libicns ] ;
+
+SubDirHdrs [ FDirName $(SUBDIR) $(DOTDOT) shared ] ;
+	#for BaseTranslator.h and friends
+	
+# Let Jam know where to find some of our source files
+SEARCH_SOURCE += [ FDirName $(SUBDIR) openjpeg ] ;
+SEARCH_SOURCE += [ FDirName $(SUBDIR) libicns ] ;
+
+SubDirC++Flags [ FDefines BEOS_R5_COMPATIBLE ] ;
+
+local openjpeg_files = 
+	bio.c
+	cio.c
+	dwt.c
+	event.c
+	image.c
+	j2k.c
+	j2k_lib.c
+	jp2.c
+	jpt.c
+	mct.c
+	mqc.c
+	openjpeg.c
+	pi.c
+	raw.c
+	t1.c
+	t2.c
+	tcd.c
+	tgt.c
+	cidx_manager.c
+	phix_manager.c
+	ppix_manager.c
+	thix_manager.c
+	tpix_manager.c
+	;
+
+ObjectCcFlags [ FGristFiles $(openjpeg_files:S=$(SUFOBJ)) ] : -w ;
+
+local libicns_files = 
+	icns_debug.c
+	icns_element.c
+	icns_family.c
+	icns_image.c
+	icns_io.c
+	icns_jp2.c
+	icns_png.c
+	icns_rle24.c
+	icns_utils.c
+	;
+
+ObjectCcFlags [ FGristFiles $(libicns_files:S=$(SUFOBJ)) ] : -w ;
+
+AddResources ICNSTranslator : ICNSTranslator.rdef ;
+
+Translator ICNSTranslator :
+
+	# ICNSTranslator
+	ICNSTranslator.cpp
+	ICNSLoader.cpp
+	ConfigView.cpp
+	main.cpp
+
+	$(openjpeg_files)
+	
+	$(libicns_files)
+
+	: be translation libtranslatorsutils.a $(TARGET_LIBSUPC++)
+	$(HAIKU_LIBPNG_LIB) $(HAIKU_LOCALE_LIBS)
+	: true
+;
+
+DoCatalogs ICNSTranslator :
+	x-vnd.Haiku-ICNSTranslator
+	:
+	ICNSTranslator.h
+	ICNSTranslator.cpp
+;
+
+Package haiku-translationkit-cvs :
+	ICNSTranslator :
+	boot home config add-ons Translators ;
+

src/add-ons/translators/icns/libicns/COPYING.LGPL-2

@@ -0,0 +1,481 @@
+                  GNU LIBRARY GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1991 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the library GPL.  It is
+ numbered 2 because it goes with version 2 of the ordinary GPL.]
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Library General Public License, applies to some
+specially designated Free Software Foundation software, and to any
+other libraries whose authors decide to use it.  You can use it for
+your libraries, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if
+you distribute copies of the library, or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link a program with the library, you must provide
+complete object files to the recipients so that they can relink them
+with the library, after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  Our method of protecting your rights has two steps: (1) copyright
+the library, and (2) offer you this license which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  Also, for each distributor's protection, we want to make certain
+that everyone understands that there is no warranty for this free
+library.  If the library is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original
+version, so that any problems introduced by others will not reflect on
+the original authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that companies distributing free
+software will individually obtain patent licenses, thus in effect
+transforming the program into proprietary software.  To prevent this,
+we have made it clear that any patent must be licensed for everyone's
+free use or not licensed at all.
+
+  Most GNU software, including some libraries, is covered by the ordinary
+GNU General Public License, which was designed for utility programs.  This
+license, the GNU Library General Public License, applies to certain
+designated libraries.  This license is quite different from the ordinary
+one; be sure to read it in full, and don't assume that anything in it is
+the same as in the ordinary license.
+
+  The reason we have a separate public license for some libraries is that
+they blur the distinction we usually make between modifying or adding to a
+program and simply using it.  Linking a program with a library, without
+changing the library, is in some sense simply using the library, and is
+analogous to running a utility program or application program.  However, in
+a textual and legal sense, the linked executable is a combined work, a
+derivative of the original library, and the ordinary General Public License
+treats it as such.
+
+  Because of this blurred distinction, using the ordinary General
+Public License for libraries did not effectively promote software
+sharing, because most developers did not use the libraries.  We
+concluded that weaker conditions might promote sharing better.
+
+  However, unrestricted linking of non-free programs would deprive the
+users of those programs of all benefit from the free status of the
+libraries themselves.  This Library General Public License is intended to
+permit developers of non-free programs to use free libraries, while
+preserving your freedom as a user of such programs to change the free
+libraries that are incorporated in them.  (We have not seen how to achieve
+this as regards changes in header files, but we have achieved it as regards
+changes in the actual functions of the Library.)  The hope is that this
+will lead to faster development of free libraries.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, while the latter only
+works together with the library.
+
+  Note that it is possible for a library to be covered by the ordinary
+General Public License rather than by this special one.
+
+                  GNU LIBRARY GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library which
+contains a notice placed by the copyright holder or other authorized
+party saying it may be distributed under the terms of this Library
+General Public License (also called "this License").  Each licensee is
+addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also compile or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    c) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    d) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the source code distributed need not include anything that is normally
+distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Library General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+                            NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!

src/add-ons/translators/icns/libicns/README

@@ -0,0 +1,118 @@
+===============================================================================
+README for libicns 0.8.1 - June 14, 2012
+Copyright (C) 2001-2012 Mathew Eis <[email protected]>
+
+Other individuals have supported the development of libicns; they are credited
+in the source files where their respective contibutions have been made.
+
+===============================================================================
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+Boston, MA 02110-1301, USA.
+
+===============================================================================
+This package include the following libraries and utilities:
+1) libicns - A library for the translation of the icns format
+2) icns2png - A utility for converting icns files into png images
+3) icontainer2icns - A utility for extracting icns files from icontainer packs
+
+You should be able to get the latest version at http://sf.net/projects/icns
+
+===============================================================================
+libicns is a library for manipulation of the Mac OS icns resource format, also
+known as the IconFamily resource type. It can read and write files from the
+Mac OS X icns format, as well as read from Mac OS resource files and macbinary
+encoded Mac OS resource forks.
+
+As of release 0.5.9, it can fully manipulate any 128x128 and smaller 32-bit
+icons, and has partial support for manipulating 8-bit, 4-bit, and 1-bit icons.
+
+When linked with Jasper, it also has full support for 256x256 and 512x512
+icon sizes within the icon family.
+
+As of release 0.8.0, it can read the PNG format introduced with OS X Lion 10.7
+
+
+Please see DEVNOTES for more information on how to use libicns
+
+===============================================================================
+Using icns2png
+
+icns2png -x OmniWeb.icns
+Converting OmniWeb.icns to OmniWeb_128x128x32.png...
+
+This will result in a file OmniWeb_128x128x32.png with a 128x128 icon from OmniWeb.icns.
+
+Run icns2png --help for more detailed information.
+
+===============================================================================
+Using icontainer2icns
+
+icontainer2icns foo.icontainer
+
+This will end up with a couple of icns files identified by the iContainer ID
+and the iContainer name in a (new) folder carrying the icontainer name
+(without any suffix)
+
+===============================================================================
+NOTICE: icontainer2icns is NOT related to www.iconfactory.com - though it
+decodes this library type. They are NOT involved, please don't bother them
+with bug reports.
+
+For bug/wishes regarding icontainer2icns mailto: [email protected]
+
+===============================================================================
+Understanding the Mac OS X Icons
+
+Mac OS X Icon files come in two formats - icns files, and icns resources
+embedded with rsrc files. They may also be stored in a macbinary encoded
+rsrc files, or applesingle/appledouble encoded rsrc files
+
+libicns (and icns2png) can decode all five storage formats
+
+The .icns files are much easier to deal with, since they are in a format that
+can be easily accesed from Linux/UNIX/Windows.
+
+You can however access the icons from the resource files. OS X Icons like
+those from http://interfacelift.com/icons-mac/ are compressed in .sit files.
+These files can be uncompressed using Aladdin Stuffit Expander for Linux,
+which can be obtained from http://www.stuffit.com/unix/index.html
+
+When unstuffing, be sure to use a command similar to the following:
+
+unstuff --text=auto --macbinary=auto --eol=unix icons.hqx.sit
+
+This will help ensure that the resource forks are uncompressed into
+MacBinary files, so that icns2png can read them.
+
+If there are resource forks in the files, when stuffit decompresses them,
+it will create two files from the one mac file. For example, if the mac
+file was named "Gnu", the resulting decomressed files will be
+"Gnu", and "Gnu_1". The "Snowflake_1" file is the resource
+fork. This is the file you will want to extract the icon from. The file
+"Gnu" does not contain any icon data. If, however, there is no
+"Gnu_1", then the file may be in the .icns format, and you will
+extract the icon from "Gnu" - resulting in a file "Gnu.png"
+
+It is really fairly simple, once you get the hang of it - you will also
+notice that if the icon was in the resource fork, then the other main
+file will be etremely small, sometimes even 0k.
+
+The underlying data in both of the files is similar - they both hold the
+following icon data (Although most icons to not have a complete set):
+16x12 pixels - 1 bit mask - 1, 4, or 8 bit icon
+16x16 pixels - 1 or 8 bit mask - 1, 4, 8 or 24 bit icon
+32x32 pixels - 1 or 8 bit mask - 1, 4, 8, or 24 bit icon
+64x64 pixels - 1 or 8 bit mask - 1, 4, 8, or 24 bit icon
+128x128 pixels - 8 bit mask - 24 bit icon

src/add-ons/translators/icns/libicns/config.h

@@ -0,0 +1,30 @@
+#define HAVE_DLFCN_H 1
+#define HAVE_FORK 1
+#define HAVE_GETOPT_H 1
+#define HAVE_INTTYPES_H 1
+#define HAVE_MEMORY_H 1
+#define HAVE_PNG_H 1
+#define HAVE_STDINT_H 1
+#define HAVE_STDLIB_H 1
+#define HAVE_STRINGS_H 1
+#define HAVE_STRING_H 1
+#define HAVE_SYS_STAT_H 1
+#define HAVE_SYS_TYPES_H 1
+#define HAVE_UNALIGNED_MEMCPY 1
+#define HAVE_UNISTD_H 1
+#define HAVE_VFORK 1
+#define HAVE_WORKING_FORK 1
+#define HAVE_WORKING_VFORK 1
+#define ICNS_OPENJPEG 1
+#define STDC_HEADERS 1
+#define VERSION "0.8.1"
+
+#if defined AC_APPLE_UNIVERSAL_BUILD
+# if defined __BIG_ENDIAN__
+#  define WORDS_BIGENDIAN 1
+# endif
+#else
+# ifndef WORDS_BIGENDIAN
+/* #  undef WORDS_BIGENDIAN */
+# endif
+#endif

src/add-ons/translators/icns/libicns/icns.h

@@ -0,0 +1,212 @@
+/*
+File:       icns.h
+Copyright (C) 2001-2012 Mathew Eis <[email protected]>
+Copyright (C) 2002 Chenxiao Zhao <[email protected]>
+
+With the exception of the limited portions mentiond, this library
+is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published
+by the Free Software Foundation; either version 2.1 of the License,
+or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, 
+Boston, MA 02110-1301, USA.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+
+#ifndef _ICNS_H_
+#define	_ICNS_H_
+
+/* basic data types */
+typedef uint8_t         icns_bool_t;
+
+typedef uint8_t         icns_uint8_t;
+typedef int8_t          icns_sint8_t;
+typedef uint16_t        icns_uint16_t;
+typedef int16_t         icns_sint16_t;
+typedef uint32_t        icns_uint32_t;
+typedef int32_t         icns_sint32_t;
+typedef uint64_t        icns_uint64_t;
+typedef int64_t         icns_sint64_t;
+
+typedef uint8_t         icns_byte_t;
+
+
+/* data header types */
+typedef uint32_t        icns_type_t;
+typedef int32_t         icns_size_t;
+
+/* icon family and element types */
+typedef struct icns_element_t {
+  icns_type_t           elementType;    /* 'ICN#', 'icl8', etc... */
+  icns_size_t           elementSize;    /* Total size of element  */
+  icns_byte_t           elementData[1]; /* icon image data */
+} icns_element_t;
+
+typedef struct icns_family_t {
+  icns_type_t           resourceType;	/* Always should be 'icns' */
+  icns_size_t           resourceSize;	/* Total size of resource  */
+  icns_element_t        elements[1];    /* icon elements */
+} icns_family_t;
+
+/* icon image data structure */
+typedef struct icns_image_t
+{
+  icns_uint32_t         imageWidth;     // width of image in pixels
+  icns_uint32_t         imageHeight;    // height of image in pixels
+  icns_uint8_t          imageChannels;  // number of channels in data
+  icns_uint16_t         imagePixelDepth;// number of bits-per-pixel
+  icns_uint64_t         imageDataSize;  // bytes = width * height * depth / bits-per-pixel
+  icns_byte_t           *imageData;     // pointer to base address of uncompressed raw image data
+} icns_image_t;
+
+/* used for getting information about various types */
+/* not part of the actual icns data format */
+typedef struct icns_icon_info_t
+{
+  icns_type_t           iconType;         // type of icon (or mask)
+  icns_bool_t           isImage;          // is this type an image
+  icns_bool_t           isMask;           // is this type a mask
+  icns_uint32_t         iconWidth;        // width of icon in pixels
+  icns_uint32_t         iconHeight;       // height of icon in pixels
+  icns_uint8_t          iconChannels;     // number of channels in data
+  icns_uint16_t         iconPixelDepth;   // number of bits-per-pixel
+  icns_uint16_t         iconBitDepth;     // overall bit depth = iconPixelDepth * iconChannels
+  icns_uint64_t         iconRawDataSize;  // uncompressed bytes = width * height * depth / bits-per-pixel
+} icns_icon_info_t;
+
+/*  icns element type constants */
+
+#define ICNS_TABLE_OF_CONTENTS        0x544F4320  // "TOC "
+
+#define ICNS_ICON_VERSION             0x69636E56  // "icnV"
+
+#define ICNS_1024x1024_32BIT_ARGB_DATA 0x69633130 // "ic10"
+
+#define ICNS_512x512_32BIT_ARGB_DATA  0x69633039  // "ic09"
+#define ICNS_256x256_32BIT_ARGB_DATA  0x69633038  // "ic08"
+
+#define ICNS_128X128_32BIT_DATA       0x69743332  // "it32"
+#define ICNS_128X128_8BIT_MASK        0x74386D6B  // "t8mk"
+
+#define ICNS_48x48_1BIT_DATA          0x69636823  // "ich#"
+#define ICNS_48x48_4BIT_DATA          0x69636834  // "ich4"
+#define ICNS_48x48_8BIT_DATA          0x69636838  // "ich8"
+#define ICNS_48x48_32BIT_DATA         0x69683332  // "ih32"
+#define ICNS_48x48_1BIT_MASK          0x69636823  // "ich#"
+#define ICNS_48x48_8BIT_MASK          0x68386D6B  // "h8mk"
+
+#define ICNS_32x32_1BIT_DATA          0x49434E23  // "ICN#"
+#define ICNS_32x32_4BIT_DATA          0x69636C34  // "icl4"
+#define ICNS_32x32_8BIT_DATA          0x69636C38  // "icl8"
+#define ICNS_32x32_32BIT_DATA         0x696C3332  // "il32"
+#define ICNS_32x32_1BIT_MASK          0x49434E23  // "ICN#"
+#define ICNS_32x32_8BIT_MASK          0x6C386D6B  // "l8mk"
+
+#define ICNS_16x16_1BIT_DATA          0x69637323  // "ics#"
+#define ICNS_16x16_4BIT_DATA          0x69637334  // "ics4"
+#define ICNS_16x16_8BIT_DATA          0x69637338  // "ics8"
+#define ICNS_16x16_32BIT_DATA         0x69733332  // "is32"
+#define ICNS_16x16_1BIT_MASK          0x69637323  // "ics#"
+#define ICNS_16x16_8BIT_MASK          0x73386D6B  // "s8mk"
+
+#define ICNS_16x12_1BIT_DATA          0x69636D23  // "icm#"
+#define ICNS_16x12_4BIT_DATA          0x69636D34  // "icm4"
+#define ICNS_16x12_1BIT_MASK          0x69636D23  // "icm#"
+#define ICNS_16x12_8BIT_DATA          0x69636D38  // "icm8"
+
+#define ICNS_32x32_1BIT_ICON          0x49434F4E  // "ICON"
+
+#define ICNS_TILE_VARIANT             0x74696C65  // "tile"
+#define ICNS_ROLLOVER_VARIANT         0x6F766572  // "over"
+#define ICNS_DROP_VARIANT             0x64726F70  // "drop"
+#define ICNS_OPEN_VARIANT             0x6F70656E  // "open"
+#define ICNS_OPEN_DROP_VARIANT        0x6F647270  // "odrp"
+
+#define ICNS_NULL_DATA                0x00000000 
+#define ICNS_NULL_MASK                0x00000000 
+
+/* icns file / resource type constants */
+
+#define ICNS_FAMILY_TYPE              0x69636E73  // "icns"
+
+#define ICNS_MACBINARY_TYPE           0x6D42494E  // "mBIN"
+
+#define ICNS_NULL_TYPE                0x00000000 
+
+/* icns error return values */
+
+#define	ICNS_STATUS_OK                0
+
+#define	ICNS_STATUS_NULL_PARAM        -1
+#define	ICNS_STATUS_NO_MEMORY         -2
+#define	ICNS_STATUS_INVALID_DATA      -3
+
+#define	ICNS_STATUS_IO_READ_ERR	      1
+#define	ICNS_STATUS_IO_WRITE_ERR      2
+#define	ICNS_STATUS_DATA_NOT_FOUND    3
+#define	ICNS_STATUS_UNSUPPORTED       4
+
+/* icns function prototypes */
+/* NOTE: internal functions are found in icns_internals.h */
+
+// icns_io.c
+int icns_write_family_to_file(FILE *dataFile,icns_family_t *iconFamilyIn);
+int icns_read_family_from_file(FILE *dataFile,icns_family_t **iconFamilyOut);
+int icns_read_family_from_rsrc(FILE *rsrcFile,icns_family_t **iconFamilyOut);
+int icns_export_family_data(icns_family_t *iconFamily,icns_size_t *dataSizeOut,icns_byte_t **dataPtrOut);
+int icns_import_family_data(icns_size_t dataSize,icns_byte_t *data,icns_family_t **iconFamilyOut);
+
+// icns_family.c
+int icns_create_family(icns_family_t **iconFamilyOut);
+int icns_count_elements_in_family(icns_family_t *iconFamily, icns_sint32_t *elementTotal);
+
+// icns_element.c
+int icns_get_element_from_family(icns_family_t *iconFamily,icns_type_t iconType,icns_element_t **iconElementOut);
+int icns_set_element_in_family(icns_family_t **iconFamilyRef,icns_element_t *newIconElement);
+int icns_add_element_in_family(icns_family_t **iconFamilyRef,icns_element_t *newIconElement);
+int icns_remove_element_in_family(icns_family_t **iconFamilyRef,icns_type_t iconType);
+int icns_new_element_from_image(icns_image_t *imageIn,icns_type_t iconType,icns_element_t **iconElementOut);
+int icns_new_element_from_mask(icns_image_t *imageIn,icns_type_t iconType,icns_element_t **iconElementOut);
+int icns_update_element_with_image(icns_image_t *imageIn,icns_element_t **iconElement);
+int icns_update_element_with_mask(icns_image_t *imageIn,icns_element_t **iconElement);
+
+// icns_image.c
+int icns_get_image32_with_mask_from_family(icns_family_t *iconFamily,icns_type_t sourceType,icns_image_t *imageOut);
+int icns_get_image_from_element(icns_element_t *iconElement,icns_image_t *imageOut);
+int icns_get_mask_from_element(icns_element_t *iconElement,icns_image_t *imageOut);
+int icns_init_image_for_type(icns_type_t iconType,icns_image_t *imageOut);
+int icns_init_image(icns_uint32_t iconWidth,icns_uint32_t iconHeight,icns_uint32_t iconChannels,icns_uint32_t iconPixelDepth,icns_image_t *imageOut);
+int icns_free_image(icns_image_t *imageIn);
+
+// icns_rle24.c
+int icns_decode_rle24_data(icns_size_t rawDataSize, icns_byte_t *rawDataPtr,icns_size_t expectedPixelCount, icns_size_t *dataSizeOut, icns_byte_t **dataPtrOut);
+int icns_encode_rle24_data(icns_size_t dataSizeIn, icns_byte_t *dataPtrIn,icns_size_t *dataSizeOut, icns_byte_t **dataPtrOut);
+
+// icns_jp2.c
+int icns_jp2_to_image(icns_size_t dataSize, icns_byte_t *dataPtr, icns_image_t *imageOut);
+int icns_image_to_jp2(icns_image_t *image, icns_size_t *dataSizeOut, icns_byte_t **dataPtrOut);
+
+// icns_utils.c
+icns_icon_info_t icns_get_image_info_for_type(icns_type_t iconType);
+icns_type_t icns_get_mask_type_for_icon_type(icns_type_t);
+icns_type_t icns_get_type_from_image_info(icns_icon_info_t iconInfo);
+icns_type_t icns_get_type_from_image(icns_image_t iconImage);
+icns_type_t icns_get_type_from_mask(icns_image_t iconImage);
+icns_bool_t icns_types_equal(icns_type_t typeA,icns_type_t typeB);
+icns_bool_t icns_types_not_equal(icns_type_t typeA,icns_type_t typeB);
+const char * icns_type_str(icns_type_t type, char *strbuf);
+void icns_set_print_errors(icns_bool_t shouldPrint);
+
+#endif

src/add-ons/translators/icns/libicns/icns_colormaps.h

@@ -0,0 +1,314 @@
+/*
+File:       icns_colormaps.h
+Copyright (C) 2001-2012 Mathew Eis <[email protected]>
+Copyright (C) 2004 Brion Vibber <[email protected]>
+Copyright (C) 2007 Lyonel Vincent <[email protected]>
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, 
+Boston, MA 02110-1301, USA.
+*/
+
+#ifndef _COLORMAPS_H_
+#define	_COLORMAPS_H_	1
+
+typedef struct icns_colormap_rgb_t
+{
+  icns_byte_t r;
+  icns_byte_t g;
+  icns_byte_t b;
+} icns_colormap_rgb_t;
+
+
+static const icns_colormap_rgb_t icns_colormap_4[] =
+{
+   {0xFF, 0xFF, 0xFF},
+   {0xFC, 0xF3, 0x05},
+   {0xFF, 0x64, 0x02},
+   {0xDD, 0x08, 0x06},
+   {0xF2, 0x08, 0x84},
+   {0x46, 0x00, 0xA5},
+   {0x00, 0x00, 0xD4},
+   {0x02, 0xAB, 0xEA},
+   {0x1F, 0xB7, 0x14},
+   {0x00, 0x64, 0x11},
+   {0x56, 0x2C, 0x05},
+   {0x90, 0x71, 0x3A},
+   {0xC0, 0xC0, 0xC0},
+   {0x80, 0x80, 0x80},
+   {0x40, 0x40, 0x40},
+   {0x00, 0x00, 0x00}
+};
+
+static const icns_colormap_rgb_t icns_colormap_8[] =
+{
+   {0xFF, 0xFF, 0xFF},
+   {0xFF, 0xFF, 0xCC},
+   {0xFF, 0xFF, 0x99},
+   {0xFF, 0xFF, 0x66},
+   {0xFF, 0xFF, 0x33},
+   {0xFF, 0xFF, 0x00},
+   {0xFF, 0xCC, 0xFF},
+   {0xFF, 0xCC, 0xCC},
+   {0xFF, 0xCC, 0x99},
+   {0xFF, 0xCC, 0x66},
+   {0xFF, 0xCC, 0x33},
+   {0xFF, 0xCC, 0x00},
+   {0xFF, 0x99, 0xFF},
+   {0xFF, 0x99, 0xCC},
+   {0xFF, 0x99, 0x99},
+   {0xFF, 0x99, 0x66},
+   {0xFF, 0x99, 0x33},
+   {0xFF, 0x99, 0x00},
+   {0xFF, 0x66, 0xFF},
+   {0xFF, 0x66, 0xCC},
+   {0xFF, 0x66, 0x99},
+   {0xFF, 0x66, 0x66},
+   {0xFF, 0x66, 0x33},
+   {0xFF, 0x66, 0x00},
+   {0xFF, 0x33, 0xFF},
+   {0xFF, 0x33, 0xCC},
+   {0xFF, 0x33, 0x99},
+   {0xFF, 0x33, 0x66},
+   {0xFF, 0x33, 0x33},
+   {0xFF, 0x33, 0x00},
+   {0xFF, 0x00, 0xFF},
+   {0xFF, 0x00, 0xCC},
+   {0xFF, 0x00, 0x99},
+   {0xFF, 0x00, 0x66},
+   {0xFF, 0x00, 0x33},
+   {0xFF, 0x00, 0x00},
+   {0xCC, 0xFF, 0xFF},
+   {0xCC, 0xFF, 0xCC},
+   {0xCC, 0xFF, 0x99},
+   {0xCC, 0xFF, 0x66},
+   {0xCC, 0xFF, 0x33},
+   {0xCC, 0xFF, 0x00},
+   {0xCC, 0xCC, 0xFF},
+   {0xCC, 0xCC, 0xCC},
+   {0xCC, 0xCC, 0x99},
+   {0xCC, 0xCC, 0x66},
+   {0xCC, 0xCC, 0x33},
+   {0xCC, 0xCC, 0x00},
+   {0xCC, 0x99, 0xFF},
+   {0xCC, 0x99, 0xCC},
+   {0xCC, 0x99, 0x99},
+   {0xCC, 0x99, 0x66},
+   {0xCC, 0x99, 0x33},
+   {0xCC, 0x99, 0x00},
+   {0xCC, 0x66, 0xFF},
+   {0xCC, 0x66, 0xCC},
+   {0xCC, 0x66, 0x99},
+   {0xCC, 0x66, 0x66},
+   {0xCC, 0x66, 0x33},
+   {0xCC, 0x66, 0x00},
+   {0xCC, 0x33, 0xFF},
+   {0xCC, 0x33, 0xCC},
+   {0xCC, 0x33, 0x99},
+   {0xCC, 0x33, 0x66},
+   {0xCC, 0x33, 0x33},
+   {0xCC, 0x33, 0x00},
+   {0xCC, 0x00, 0xFF},
+   {0xCC, 0x00, 0xCC},
+   {0xCC, 0x00, 0x99},
+   {0xCC, 0x00, 0x66},
+   {0xCC, 0x00, 0x33},
+   {0xCC, 0x00, 0x00},
+   {0x99, 0xFF, 0xFF},
+   {0x99, 0xFF, 0xCC},
+   {0x99, 0xFF, 0x99},
+   {0x99, 0xFF, 0x66},
+   {0x99, 0xFF, 0x33},
+   {0x99, 0xFF, 0x00},
+   {0x99, 0xCC, 0xFF},
+   {0x99, 0xCC, 0xCC},
+   {0x99, 0xCC, 0x99},
+   {0x99, 0xCC, 0x66},
+   {0x99, 0xCC, 0x33},
+   {0x99, 0xCC, 0x00},
+   {0x99, 0x99, 0xFF},
+   {0x99, 0x99, 0xCC},
+   {0x99, 0x99, 0x99},
+   {0x99, 0x99, 0x66},
+   {0x99, 0x99, 0x33},
+   {0x99, 0x99, 0x00},
+   {0x99, 0x66, 0xFF},
+   {0x99, 0x66, 0xCC},
+   {0x99, 0x66, 0x99},
+   {0x99, 0x66, 0x66},
+   {0x99, 0x66, 0x33},
+   {0x99, 0x66, 0x00},
+   {0x99, 0x33, 0xFF},
+   {0x99, 0x33, 0xCC},
+   {0x99, 0x33, 0x99},
+   {0x99, 0x33, 0x66},
+   {0x99, 0x33, 0x33},
+   {0x99, 0x33, 0x00},
+   {0x99, 0x00, 0xFF},
+   {0x99, 0x00, 0xCC},
+   {0x99, 0x00, 0x99},
+   {0x99, 0x00, 0x66},
+   {0x99, 0x00, 0x33},
+   {0x99, 0x00, 0x00},
+   {0x66, 0xFF, 0xFF},
+   {0x66, 0xFF, 0xCC},
+   {0x66, 0xFF, 0x99},
+   {0x66, 0xFF, 0x66},
+   {0x66, 0xFF, 0x33},
+   {0x66, 0xFF, 0x00},
+   {0x66, 0xCC, 0xFF},
+   {0x66, 0xCC, 0xCC},
+   {0x66, 0xCC, 0x99},
+   {0x66, 0xCC, 0x66},
+   {0x66, 0xCC, 0x33},
+   {0x66, 0xCC, 0x00},
+   {0x66, 0x99, 0xFF},
+   {0x66, 0x99, 0xCC},
+   {0x66, 0x99, 0x99},
+   {0x66, 0x99, 0x66},
+   {0x66, 0x99, 0x33},
+   {0x66, 0x99, 0x00},
+   {0x66, 0x66, 0xFF},
+   {0x66, 0x66, 0xCC},
+   {0x66, 0x66, 0x99},
+   {0x66, 0x66, 0x66},
+   {0x66, 0x66, 0x33},
+   {0x66, 0x66, 0x00},
+   {0x66, 0x33, 0xFF},
+   {0x66, 0x33, 0xCC},
+   {0x66, 0x33, 0x99},
+   {0x66, 0x33, 0x66},
+   {0x66, 0x33, 0x33},
+   {0x66, 0x33, 0x00},
+   {0x66, 0x00, 0xFF},
+   {0x66, 0x00, 0xCC},
+   {0x66, 0x00, 0x99},
+   {0x66, 0x00, 0x66},
+   {0x66, 0x00, 0x33},
+   {0x66, 0x00, 0x00},
+   {0x33, 0xFF, 0xFF},
+   {0x33, 0xFF, 0xCC},
+   {0x33, 0xFF, 0x99},
+   {0x33, 0xFF, 0x66},
+   {0x33, 0xFF, 0x33},
+   {0x33, 0xFF, 0x00},
+   {0x33, 0xCC, 0xFF},
+   {0x33, 0xCC, 0xCC},
+   {0x33, 0xCC, 0x99},
+   {0x33, 0xCC, 0x66},
+   {0x33, 0xCC, 0x33},
+   {0x33, 0xCC, 0x00},
+   {0x33, 0x99, 0xFF},
+   {0x33, 0x99, 0xCC},
+   {0x33, 0x99, 0x99},
+   {0x33, 0x99, 0x66},
+   {0x33, 0x99, 0x33},
+   {0x33, 0x99, 0x00},
+   {0x33, 0x66, 0xFF},
+   {0x33, 0x66, 0xCC},
+   {0x33, 0x66, 0x99},
+   {0x33, 0x66, 0x66},
+   {0x33, 0x66, 0x33},
+   {0x33, 0x66, 0x00},
+   {0x33, 0x33, 0xFF},
+   {0x33, 0x33, 0xCC},
+   {0x33, 0x33, 0x99},
+   {0x33, 0x33, 0x66},
+   {0x33, 0x33, 0x33},
+   {0x33, 0x33, 0x00},
+   {0x33, 0x00, 0xFF},
+   {0x33, 0x00, 0xCC},
+   {0x33, 0x00, 0x99},
+   {0x33, 0x00, 0x66},
+   {0x33, 0x00, 0x33},
+   {0x33, 0x00, 0x00},
+   {0x00, 0xFF, 0xFF},
+   {0x00, 0xFF, 0xCC},
+   {0x00, 0xFF, 0x99},
+   {0x00, 0xFF, 0x66},
+   {0x00, 0xFF, 0x33},
+   {0x00, 0xFF, 0x00},
+   {0x00, 0xCC, 0xFF},
+   {0x00, 0xCC, 0xCC},
+   {0x00, 0xCC, 0x99},
+   {0x00, 0xCC, 0x66},
+   {0x00, 0xCC, 0x33},
+   {0x00, 0xCC, 0x00},
+   {0x00, 0x99, 0xFF},
+   {0x00, 0x99, 0xCC},
+   {0x00, 0x99, 0x99},
+   {0x00, 0x99, 0x66},
+   {0x00, 0x99, 0x33},
+   {0x00, 0x99, 0x00},
+   {0x00, 0x66, 0xFF},
+   {0x00, 0x66, 0xCC},
+   {0x00, 0x66, 0x99},
+   {0x00, 0x66, 0x66},
+   {0x00, 0x66, 0x33},
+   {0x00, 0x66, 0x00},
+   {0x00, 0x33, 0xFF},
+   {0x00, 0x33, 0xCC},
+   {0x00, 0x33, 0x99},
+   {0x00, 0x33, 0x66},
+   {0x00, 0x33, 0x33},
+   {0x00, 0x33, 0x00},
+   {0x00, 0x00, 0xFF},
+   {0x00, 0x00, 0xCC},
+   {0x00, 0x00, 0x99},
+   {0x00, 0x00, 0x66},
+   {0x00, 0x00, 0x33},
+   {0xEE, 0x00, 0x00},
+   {0xDD, 0x00, 0x00},
+   {0xBB, 0x00, 0x00},
+   {0xAA, 0x00, 0x00},
+   {0x88, 0x00, 0x00},
+   {0x77, 0x00, 0x00},
+   {0x55, 0x00, 0x00},
+   {0x44, 0x00, 0x00},
+   {0x22, 0x00, 0x00},
+   {0x11, 0x00, 0x00},
+   {0x00, 0xEE, 0x00},
+   {0x00, 0xDD, 0x00},
+   {0x00, 0xBB, 0x00},
+   {0x00, 0xAA, 0x00},
+   {0x00, 0x88, 0x00},
+   {0x00, 0x77, 0x00},
+   {0x00, 0x55, 0x00},
+   {0x00, 0x44, 0x00},
+   {0x00, 0x22, 0x00},
+   {0x00, 0x11, 0x00},
+   {0x00, 0x00, 0xEE},
+   {0x00, 0x00, 0xDD},
+   {0x00, 0x00, 0xBB},
+   {0x00, 0x00, 0xAA},
+   {0x00, 0x00, 0x88},
+   {0x00, 0x00, 0x77},
+   {0x00, 0x00, 0x55},
+   {0x00, 0x00, 0x44},
+   {0x00, 0x00, 0x22},
+   {0x00, 0x00, 0x11},
+   {0xEE, 0xEE, 0xEE},
+   {0xDD, 0xDD, 0xDD},
+   {0xBB, 0xBB, 0xBB},
+   {0xAA, 0xAA, 0xAA},
+   {0x88, 0x88, 0x88},
+   {0x77, 0x77, 0x77},
+   {0x55, 0x55, 0x55},
+   {0x44, 0x44, 0x44},
+   {0x22, 0x22, 0x22},
+   {0x11, 0x11, 0x11},
+   {0x00, 0x00, 0x00}
+};
+
+#endif /*_COLORMAPS_H_ */

src/add-ons/translators/icns/libicns/icns_debug.c

@@ -0,0 +1,61 @@
+/*
+File:       icns_debug.c
+Copyright (C) 2001-2012 Mathew Eis <[email protected]>
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, 
+Boston, MA 02110-1301, USA.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "icns.h"
+#include "icns_internals.h"
+#ifdef ICNS_DEBUG
+void bin_print_byte(int x)
+{
+   int n;
+   for(n=0; n<8; n++)
+   {
+	if((x & 0x80) !=0)
+	{
+	printf("1");
+	}
+	else
+	{
+   	printf("0");
+   	}
+	if(n==3)
+	{
+	printf(" "); /* insert a space between nybbles */
+	}
+	x = x<<1;
+   }
+}
+
+void bin_print_int(int x)
+{
+   int hi, lo;
+   hi=(x>>8) & 0xff;
+   lo=x&0xff;
+   bin_print_byte(hi);
+   printf(" ");
+   bin_print_byte(lo);
+}
+#endif /* ifdef ICNS_DEBUG */
+
+

src/add-ons/translators/icns/libicns/icns_element.c

@@ -0,0 +1,740 @@
+/*
+File:       icns_element.c
+Copyright (C) 2001-2012 Mathew Eis <[email protected]>
+              2007 Thomas Lübking <[email protected]>
+              2002 Chenxiao Zhao <[email protected]>
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, 
+Boston, MA 02110-1301, USA.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "icns.h"
+#include "icns_internals.h"
+
+
+//***************************** icns_get_element_from_family **************************//
+// Parses requested data from an icon family - puts it into a icon element
+
+int icns_get_element_from_family(icns_family_t *iconFamily,icns_type_t iconType,icns_element_t **iconElementOut)
+{
+	int		error = ICNS_STATUS_OK;
+	int		foundData = 0;
+	icns_type_t	iconFamilyType = ICNS_NULL_TYPE;
+	icns_size_t	iconFamilySize = 0;
+	icns_element_t	*iconElement = NULL;
+	icns_type_t	elementType = ICNS_NULL_TYPE;
+	icns_size_t	elementSize = 0;
+	icns_uint32_t	dataOffset = 0;
+	
+	if(iconFamily == NULL)
+	{
+		icns_print_err("icns_get_element_from_family: icns family is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	if(iconElementOut == NULL)
+	{
+		icns_print_err("icns_get_element_in_family: icns element out is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	else
+	{
+		*iconElementOut = NULL;
+	}
+	
+	if(iconFamily->resourceType != ICNS_FAMILY_TYPE)
+	{
+		icns_print_err("icns_get_element_from_family: Invalid icns family!\n");
+		return ICNS_STATUS_INVALID_DATA;
+	}
+	
+	ICNS_READ_UNALIGNED(iconFamilyType, &(iconFamily->resourceType),sizeof( icns_type_t));
+	ICNS_READ_UNALIGNED(iconFamilySize, &(iconFamily->resourceSize),sizeof( icns_size_t));
+	
+	#ifdef ICNS_DEBUG
+	{
+		char typeStr[5];
+		printf("Looking for icon element of type: '%s'\n",icns_type_str(iconType,typeStr));
+		printf("  icon family type check: '%s'\n",icns_type_str(iconFamilyType,typeStr));
+		printf("  icon family size check: %d\n",iconFamilySize);
+	}
+	#endif
+	
+	dataOffset = sizeof(icns_type_t) + sizeof(icns_size_t);
+	
+	while ( (foundData == 0) && (dataOffset < iconFamilySize) )
+	{
+		iconElement = ((icns_element_t*)(((icns_byte_t*)iconFamily)+dataOffset));
+		
+		if( iconFamilySize < (dataOffset+sizeof(icns_type_t)+sizeof(icns_size_t)) )
+		{
+			icns_print_err("icns_get_element_from_family: Corrupted icns family!\n");
+			return ICNS_STATUS_INVALID_DATA;		
+		}
+		
+		ICNS_READ_UNALIGNED(elementType, &(iconElement->elementType),sizeof( icns_type_t));
+		ICNS_READ_UNALIGNED(elementSize, &(iconElement->elementSize),sizeof( icns_size_t));
+		
+		#ifdef ICNS_DEBUG
+		{
+			char typeStr[5];
+			printf("element data...\n");
+			printf("  type: '%s'%s\n",icns_type_str(elementType,typeStr),(elementType == iconType) ? " - match!" : " ");
+			printf("  size: %d\n",(int)elementSize);
+		}
+		#endif
+		
+		if( (elementSize < 8) || ((dataOffset+elementSize) > iconFamilySize) )
+		{
+			icns_print_err("icns_get_element_from_family: Invalid element size! (%d)\n",elementSize);
+			return ICNS_STATUS_INVALID_DATA;
+		}
+		
+		if(elementType == iconType)
+			foundData = 1;
+		else
+			dataOffset += elementSize;
+	}
+	
+	if(foundData)
+	{
+		*iconElementOut = malloc(elementSize);
+		if(*iconElementOut == NULL)
+		{
+			icns_print_err("icns_get_element_from_family: Unable to allocate memory block of size: %d!\n",elementSize);
+			return ICNS_STATUS_NO_MEMORY;
+		}
+		memcpy( *iconElementOut, iconElement, elementSize);
+	}
+	else
+	{
+		icns_print_err("icns_get_element_from_family: Unable to find requested icon data!\n");
+		error = ICNS_STATUS_DATA_NOT_FOUND;
+	}
+	
+	return error;
+}
+
+//***************************** icns_set_element_in_family **************************//
+// Adds/updates the icns element of it's type in the icon family
+
+int icns_set_element_in_family(icns_family_t **iconFamilyRef,icns_element_t *newIconElement)
+{
+	int		error = ICNS_STATUS_OK;
+	int		foundData = 0;
+	int		copiedData = 0;
+	icns_family_t	*iconFamily = NULL;
+	icns_type_t	iconFamilyType = ICNS_NULL_TYPE;
+	icns_size_t	iconFamilySize = 0;
+	icns_element_t	*iconElement = NULL;
+	icns_type_t	newElementType = ICNS_NULL_TYPE;
+	icns_size_t	newElementSize = 0;
+	icns_type_t	elementType = ICNS_NULL_TYPE;
+	icns_size_t	elementSize = 0;
+	icns_uint32_t	dataOffset = 0;
+	icns_size_t	newIconFamilySize = 0;
+	icns_family_t	*newIconFamily = NULL;
+	icns_uint32_t	newDataOffset = 0;
+	icns_uint32_t	elementOrder = 0;
+	icns_uint32_t   newElementOrder = 0;
+
+	
+	if(iconFamilyRef == NULL)
+	{
+		icns_print_err("icns_set_element_in_family: icns family reference is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	iconFamily = *iconFamilyRef;
+	
+	if(iconFamily == NULL)
+	{
+		icns_print_err("icns_set_element_in_family: icns family is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	#ifdef ICNS_DEBUG
+	printf("Setting element in icon family...\n");
+	#endif
+	
+	if(iconFamily->resourceType != ICNS_FAMILY_TYPE)
+	{
+		icns_print_err("icns_set_element_in_family: Invalid icns family!\n");
+		error = ICNS_STATUS_INVALID_DATA;
+	}
+	
+	ICNS_READ_UNALIGNED(iconFamilyType, &(iconFamily->resourceType),sizeof( icns_type_t));
+	ICNS_READ_UNALIGNED(iconFamilySize, &(iconFamily->resourceSize),sizeof( icns_size_t));
+	
+	#ifdef ICNS_DEBUG
+	{
+		char typeStr[5];
+		printf("  family type '%s'\n",icns_type_str(iconFamilyType,typeStr));
+		printf("  family size: %d (0x%08X)\n",(int)iconFamilySize,iconFamilySize);
+	}
+	#endif
+	
+	if(newIconElement == NULL)
+	{
+		icns_print_err("icns_set_element_in_family: icns element is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	// Retrieve first, then swap. May help with problems on some arch	
+	ICNS_READ_UNALIGNED(newElementType, &(newIconElement->elementType),sizeof( icns_type_t));
+	ICNS_READ_UNALIGNED(newElementSize, &(newIconElement->elementSize),sizeof( icns_size_t));
+	
+	#ifdef ICNS_DEBUG
+	{
+		char typeStr[5];
+		printf("  element type '%s'\n",icns_type_str(newElementType,typeStr));
+		printf("  element size: %d (0x%08X)\n",(int)newElementSize,newElementSize);
+	}
+	#endif
+	
+	dataOffset = sizeof(icns_type_t) + sizeof(icns_size_t);
+	
+	while ( (foundData == 0) && (dataOffset < iconFamilySize) )
+	{
+		iconElement = ((icns_element_t*)(((char*)iconFamily)+dataOffset));
+		ICNS_READ_UNALIGNED(elementType, &(iconElement->elementType),sizeof( icns_type_t));
+		ICNS_READ_UNALIGNED(elementSize, &(iconElement->elementSize),sizeof( icns_size_t));
+		
+		if(elementType == newElementType)
+			foundData = 1;
+		else
+			dataOffset += elementSize;
+	}
+	
+	if(foundData)
+		newIconFamilySize = iconFamilySize - elementSize + newElementSize;
+	else
+		newIconFamilySize = iconFamilySize + newElementSize;
+	
+	#ifdef ICNS_DEBUG
+	printf("  new family type 'icns'\n");
+	printf("  new family size: %d (0x%08X)\n",(int)newIconFamilySize,newIconFamilySize);
+	#endif
+	
+	newIconFamily = malloc(newIconFamilySize);
+	
+	if(newIconFamily == NULL)
+	{
+		icns_print_err("icns_set_element_in_family: Unable to allocate memory block of size: %d!\n",newIconFamilySize);
+		return ICNS_STATUS_NO_MEMORY;
+	}
+	
+	newIconFamily->resourceType = ICNS_FAMILY_TYPE;
+	newIconFamily->resourceSize = newIconFamilySize;
+	
+	newDataOffset = sizeof(icns_type_t) + sizeof(icns_size_t);
+	dataOffset = sizeof(icns_type_t) + sizeof(icns_size_t);
+	
+	copiedData = 0;
+	
+	newElementOrder = icns_get_element_order(newElementType);
+	
+	while ( dataOffset < iconFamilySize )
+	{
+		iconElement = ((icns_element_t*)(((char*)iconFamily)+dataOffset));
+		ICNS_READ_UNALIGNED(elementType, &(iconElement->elementType),sizeof( icns_type_t));
+		ICNS_READ_UNALIGNED(elementSize, &(iconElement->elementSize),sizeof( icns_size_t));
+		elementOrder = icns_get_element_order(elementType);
+		
+		if(!copiedData && (elementType == newElementType))
+		{
+			memcpy( ((char *)(newIconFamily))+newDataOffset , (char *)newIconElement, newElementSize);
+			newDataOffset += newElementSize;
+			copiedData = 1;
+		}
+		else if(!copiedData && !foundData && newElementOrder < elementOrder)
+		{
+			memcpy( ((char *)(newIconFamily))+newDataOffset , (char *)newIconElement, newElementSize);
+			newDataOffset += newElementSize;
+			copiedData = 1;
+			
+			memcpy( ((char *)(newIconFamily))+newDataOffset , ((char *)(iconFamily))+dataOffset, elementSize);
+			newDataOffset += elementSize;
+		}
+		else
+		{
+			memcpy( ((char *)(newIconFamily))+newDataOffset , ((char *)(iconFamily))+dataOffset, elementSize);
+			newDataOffset += elementSize;
+		}
+		
+		dataOffset += elementSize;
+	}
+	
+	if(!copiedData)
+	{
+		memcpy( ((char *)(newIconFamily))+newDataOffset , (char *)newIconElement, newElementSize);
+		newDataOffset += newElementSize;
+	}
+	
+	*iconFamilyRef = newIconFamily;
+	
+	free(iconFamily);
+	
+	return error;
+}
+
+//***************************** icns_add_element_in_family **************************//
+// Adds/updates the icns element of it's type in the icon family
+// A convenience alias to icns_set_element_in_family
+
+int icns_add_element_in_family(icns_family_t **iconFamilyRef,icns_element_t *newIconElement)
+{
+	if(iconFamilyRef == NULL)
+	{
+		icns_print_err("icns_add_element_in_family: icns family reference is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	if(newIconElement == NULL)
+	{
+		icns_print_err("icns_add_element_in_family: icon element is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	return icns_set_element_in_family(iconFamilyRef,newIconElement);
+}
+
+//***************************** icns_remove_element_in_family **************************//
+// Parses requested data from an icon family - puts it into a "raw" image format
+
+int icns_remove_element_in_family(icns_family_t **iconFamilyRef,icns_type_t iconElementType)
+{
+	int		error = ICNS_STATUS_OK;
+	int		foundData = 0;
+	icns_family_t	*iconFamily = NULL;
+	icns_type_t	iconFamilyType = ICNS_NULL_TYPE;
+	icns_size_t	iconFamilySize = 0;
+	icns_element_t	*iconElement = NULL;
+	icns_type_t	elementType = ICNS_NULL_TYPE;
+	icns_size_t	elementSize = 0;
+	icns_uint32_t	dataOffset = 0;
+
+	icns_size_t	newIconFamilySize = 0;
+	icns_family_t	*newIconFamily = NULL;
+	icns_uint32_t	newDataOffset = 0;	
+	
+	if(iconFamilyRef == NULL)
+	{
+		icns_print_err("icns_remove_element_in_family: icon family reference is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	iconFamily = *iconFamilyRef;
+	
+	if(iconFamily == NULL)
+	{
+		icns_print_err("icns_remove_element_in_family: icon family is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	if(iconFamily->resourceType != ICNS_FAMILY_TYPE)
+	{
+		icns_print_err("icns_remove_element_in_family: Invalid icon family!\n");
+		error = ICNS_STATUS_INVALID_DATA;
+	}
+	
+	ICNS_READ_UNALIGNED(iconFamilyType, &(iconFamily->resourceType),sizeof( icns_type_t));
+	ICNS_READ_UNALIGNED(iconFamilySize, &(iconFamily->resourceSize),sizeof( icns_size_t));
+	
+	dataOffset = sizeof(icns_type_t) + sizeof(icns_size_t);
+	
+	while ( (foundData == 0) && (dataOffset < iconFamilySize) )
+	{
+		iconElement = ((icns_element_t*)(((char*)iconFamily)+dataOffset));
+		ICNS_READ_UNALIGNED(elementType, &(iconElement->elementType),sizeof( icns_type_t));
+		ICNS_READ_UNALIGNED(elementSize, &(iconElement->elementSize),sizeof( icns_size_t));
+		
+		if(elementType == iconElementType)
+			foundData = 1;
+		else
+			dataOffset += elementSize;
+	}
+	
+	if(!foundData)
+	{
+		icns_print_err("icns_remove_element_in_family: Unable to find requested icon data for removal!\n");
+		return ICNS_STATUS_DATA_NOT_FOUND;
+	}
+
+	
+	newIconFamilySize = iconFamilySize - elementSize;
+	newIconFamily = malloc(newIconFamilySize);
+	
+	if(newIconFamily == NULL)
+	{
+		icns_print_err("icns_remove_element_in_family: Unable to allocate memory block of size: %d!\n",newIconFamilySize);
+		return ICNS_STATUS_NO_MEMORY;
+	}
+	
+	newIconFamily->resourceType = ICNS_FAMILY_TYPE;
+	newIconFamily->resourceSize = newIconFamilySize;
+	
+	newDataOffset = sizeof(icns_type_t) + sizeof(icns_size_t);
+	dataOffset = sizeof(icns_type_t) + sizeof(icns_size_t);
+	
+	while ( dataOffset < iconFamilySize )
+	{
+		iconElement = ((icns_element_t*)(((char*)iconFamily)+dataOffset));
+		ICNS_READ_UNALIGNED(elementType, &(iconElement->elementType),sizeof( icns_type_t));
+		ICNS_READ_UNALIGNED(elementSize, &(iconElement->elementSize),sizeof( icns_size_t));
+		
+		if(elementType != iconElementType)
+		{
+			memcpy( ((char *)(newIconFamily))+newDataOffset , ((char *)(iconFamily))+dataOffset, elementSize);
+			newDataOffset += elementSize;
+		}
+		
+		dataOffset += elementSize;
+	}
+	
+	*iconFamilyRef = newIconFamily;
+
+	free(iconFamily);
+	
+	return error;
+}
+
+
+
+//***************************** icns_new_element_from_image **************************//
+// Creates a new icon element from an image
+int icns_new_element_from_image(icns_image_t *imageIn,icns_type_t iconType,icns_element_t **iconElementOut)
+{
+	return icns_new_element_from_image_or_mask(imageIn,iconType,0,iconElementOut);
+}
+
+//***************************** icns_new_element_from_mask **************************//
+// Creates a new icon element from an image
+int icns_new_element_from_mask(icns_image_t *imageIn,icns_type_t iconType,icns_element_t **iconElementOut)
+{
+	return icns_new_element_from_image_or_mask(imageIn,iconType,1,iconElementOut);
+}
+
+
+//***************************** icns_new_element_from_image_or_mask **************************//
+// Creates a new icon element from an image
+int icns_new_element_from_image_or_mask(icns_image_t *imageIn,icns_type_t iconType,icns_bool_t isMask,icns_element_t **iconElementOut)
+{
+	icns_element_t	*newElement = NULL;
+	icns_size_t	newElementSize = 0;
+	
+	if(iconElementOut == NULL)
+	{
+		icns_print_err("icns_new_element_with_image_or_mask: Icon element reference is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	else
+	{
+		*iconElementOut = NULL;
+	}
+	
+	newElementSize = sizeof(icns_type_t) + sizeof(icns_size_t);
+	newElement = (icns_element_t *)malloc(newElementSize);
+	if(newElement == NULL)
+	{
+		icns_print_err("icns_new_element_with_image_or_mask: Unable to allocate memory block of size: %d!\n",(int)newElementSize);
+		return ICNS_STATUS_NO_MEMORY;
+	}
+	
+	newElement->elementType = iconType;
+	newElement->elementSize = newElementSize;
+	*iconElementOut = newElement;
+	
+	return icns_update_element_with_image_or_mask(imageIn,isMask,iconElementOut);
+}
+
+//***************************** icns_update_element_from_image **************************//
+// Updates an icon element with the given image
+int icns_update_element_with_image(icns_image_t *imageIn,icns_element_t **iconElement)
+{
+	return icns_update_element_with_image_or_mask(imageIn,0,iconElement);
+}
+
+//***************************** icns_update_element_from_mask **************************//
+// Updates an icon element with the given mask
+int icns_update_element_with_mask(icns_image_t *imageIn,icns_element_t **iconElement)
+{
+	return icns_update_element_with_image_or_mask(imageIn,1,iconElement);
+}
+
+//***************************** icns_update_element_with_image_or_mask **************************//
+// Updates an icon element with the given image or mask
+int icns_update_element_with_image_or_mask(icns_image_t *imageIn,icns_bool_t isMask,icns_element_t **iconElement)
+{
+	int		        error = ICNS_STATUS_OK;
+	icns_type_t             iconType;
+	icns_icon_info_t 	iconInfo;
+
+	// Finally, done with all the preliminary checks
+	icns_size_t	imageDataSize = 0;
+	icns_byte_t	*imageDataPtr = NULL;
+	
+	// For use to easily track deallocation if we use rle24, or jp2
+	icns_size_t	newDataSize = 0;
+	icns_byte_t	*newDataPtr = NULL;
+	
+	
+	if(imageIn == NULL)
+	{
+		icns_print_err("icns_update_element_with_image_or_mask: Icon image is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	if(iconElement == NULL)
+	{
+		icns_print_err("icns_update_element_with_image_or_mask: Icon element reference is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	if(*iconElement == NULL)
+	{
+		icns_print_err("icns_update_element_with_image_or_mask: Icon element is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	iconType = (*iconElement)->elementType;
+	
+	if(iconType == ICNS_NULL_DATA) {
+		icns_print_err("icns_update_element_with_image_or_mask: Invalid icon type!\n");
+		return ICNS_STATUS_INVALID_DATA;
+	}
+	
+	// Determine what the height and width ought to be, to check the incoming image
+	iconInfo = icns_get_image_info_for_type(iconType);
+	
+	// Check the image width, height, and pixel depth
+	
+	if(imageIn->imageWidth != iconInfo.iconWidth)
+	{
+		icns_print_err("icns_update_element_with_image_or_mask: Invalid input image width: %d\n",imageIn->imageWidth);
+		return ICNS_STATUS_INVALID_DATA;
+	}
+	
+	if(imageIn->imageWidth != iconInfo.iconWidth)
+	{
+		icns_print_err("icns_update_element_with_image_or_mask: Invalid input image width: %d\n",imageIn->imageWidth);
+		return ICNS_STATUS_INVALID_DATA;
+	}
+	
+	if(imageIn->imageHeight != iconInfo.iconHeight)
+	{
+		icns_print_err("icns_update_element_with_image_or_mask: Invalid input image height: %d\n",imageIn->imageHeight);
+		return ICNS_STATUS_INVALID_DATA;
+	}
+	
+	if(imageIn->imagePixelDepth != (iconInfo.iconBitDepth/iconInfo.iconChannels))
+	{
+		icns_print_err("icns_update_element_with_image_or_mask: libicns does't support bit depth conversion yet.\n");
+		return ICNS_STATUS_INVALID_DATA;
+	}
+	
+	// Check the image data size and data pointer
+	
+	if(imageIn->imageDataSize == 0)
+	{
+		icns_print_err("icns_update_element_with_image_or_mask: Invalid input image data size: %d\n",(int)imageIn->imageDataSize);
+		return ICNS_STATUS_INVALID_DATA;
+	}
+	
+	if(imageIn->imageData == NULL)
+	{
+		icns_print_err("icns_update_element_with_image_or_mask: Invalid input image data\n");
+		return ICNS_STATUS_INVALID_DATA;
+	}
+		
+	switch(iconType)
+	{
+	case ICNS_1024x1024_32BIT_ARGB_DATA:
+	case ICNS_256x256_32BIT_ARGB_DATA:
+	case ICNS_512x512_32BIT_ARGB_DATA:
+		error = icns_image_to_jp2(imageIn,&newDataSize,&newDataPtr);
+		imageDataSize = newDataSize;
+		imageDataPtr = newDataPtr;
+		break;
+	case ICNS_128X128_32BIT_DATA:
+	case ICNS_48x48_32BIT_DATA:
+	case ICNS_32x32_32BIT_DATA:
+	case ICNS_16x16_32BIT_DATA:
+		newDataSize = imageIn->imageDataSize;
+		
+		// Note: icns_encode_rle24_data allocates memory that must be freed later
+		if( (error = icns_encode_rle24_data(imageIn->imageDataSize,imageIn->imageData,&newDataSize,&newDataPtr)) )
+		{
+			icns_print_err("icns_update_element_with_image_or_mask: Error rle encoding image data.\n");
+			error = ICNS_STATUS_INVALID_DATA;
+		}
+		
+		imageDataSize = newDataSize;
+		imageDataPtr = newDataPtr;
+		break;
+	// Note that ICNS_NNxNN_1BIT_DATA == ICNS_NNxNN_1BIT_MASK
+	// so we do not need to put them here twice
+	case ICNS_48x48_1BIT_DATA:
+	case ICNS_32x32_1BIT_DATA:
+	case ICNS_16x16_1BIT_DATA:
+	case ICNS_16x12_1BIT_DATA:
+		{
+			icns_byte_t	*existingData = NULL;
+			icns_size_t	existingDataSize = 0;
+			icns_size_t	existingDataOffset = 0;
+			
+			if(imageIn->imageDataSize != iconInfo.iconRawDataSize)
+			{
+				icns_print_err("icns_update_element_with_image_or_mask: Invalid input image data size: %d!\n",imageIn->imageDataSize);
+				return ICNS_STATUS_INVALID_DATA;
+			}
+			
+			newDataSize = iconInfo.iconRawDataSize * 2;
+			newDataPtr = (icns_byte_t *)malloc(newDataSize);
+			if(newDataPtr == NULL)
+			{
+				icns_print_err("icns_update_element_with_image_or_mask: Unable to allocate memory block of size: %d!\n",newDataSize);
+				error = ICNS_STATUS_NO_MEMORY;
+				goto exception;
+			}
+			
+			memset (newDataPtr,0,newDataSize);
+			
+			existingData = (icns_byte_t*)(*iconElement);
+			existingDataOffset = sizeof(icns_type_t) + sizeof(icns_size_t);
+			existingDataSize = (*iconElement)->elementSize - existingDataOffset;
+			
+			// No icon data
+			if(existingDataSize == 0)
+			{
+				if(isMask == 0) {
+					memcpy(newDataPtr,imageIn->imageData,imageIn->imageDataSize);
+				} else {
+					memcpy(newDataPtr,imageIn->imageData + iconInfo.iconRawDataSize,imageIn->imageDataSize);
+				}
+			}
+			// Only image data
+			else if(existingDataSize == iconInfo.iconRawDataSize)
+			{
+				if(isMask == 0) {
+					memcpy(newDataPtr,imageIn->imageData,imageIn->imageDataSize);
+				} else {
+					memcpy(newDataPtr,existingData+existingDataOffset,iconInfo.iconRawDataSize);
+					memcpy(newDataPtr,imageIn->imageData + iconInfo.iconRawDataSize,imageIn->imageDataSize);
+				}
+			}
+			// Image + Mask data
+			else if(existingDataSize == newDataSize)
+			{
+				if(isMask == 0) {
+					memcpy(newDataPtr,imageIn->imageData,imageIn->imageDataSize);
+					memcpy(newDataPtr,existingData+existingDataOffset+iconInfo.iconRawDataSize,iconInfo.iconRawDataSize);
+				} else {
+					memcpy(newDataPtr,existingData+existingDataOffset,iconInfo.iconRawDataSize);
+					memcpy(newDataPtr,imageIn->imageData + iconInfo.iconRawDataSize,imageIn->imageDataSize);
+				}
+			}
+			else
+			{
+				icns_print_err("icns_update_element_with_image_or_mask: Unexpected element data size: %d!\n",existingDataSize);
+				error = ICNS_STATUS_INVALID_DATA;
+				goto exception;
+			}
+			
+			imageDataSize = newDataSize;
+			imageDataPtr = newDataPtr;
+		}
+		break;
+	default:
+		imageDataSize = imageIn->imageDataSize;
+		imageDataPtr = imageIn->imageData;
+		break;
+	}
+	
+	if(error == ICNS_STATUS_OK)
+	{
+		icns_element_t	*newElement = NULL;
+		icns_size_t	newElementSize = 0;
+		icns_type_t	newElementType = ICNS_NULL_DATA;
+		icns_size_t	newElementHeaderSize = 0;
+		
+		if(imageDataSize == 0)
+		{
+			icns_print_err("icns_update_element_with_image_or_mask: Image data size should not be 0!\n");
+			error = ICNS_STATUS_INVALID_DATA;
+			goto exception;
+		}
+		
+		if(imageDataPtr == NULL)
+		{
+			icns_print_err("icns_update_element_with_image_or_mask: Image data should not be NULL!\n");
+			error = ICNS_STATUS_INVALID_DATA;
+			goto exception;
+		}
+
+		// Set up and create the new element
+		newElementHeaderSize = sizeof(icns_type_t) + sizeof(icns_size_t);
+		newElementSize = newElementHeaderSize + imageDataSize;
+		newElementType = iconType;
+		
+		newElement = (icns_element_t *)malloc(newElementSize);
+		
+		if(newElement == NULL)
+		{
+			icns_print_err("icns_update_element_with_image_or_mask: Unable to allocate memory block of size: %d!\n",(int)newElementSize);
+			error = ICNS_STATUS_NO_MEMORY;
+			goto exception;
+		}
+		
+		// Set up the element info
+		newElement->elementType = newElementType;
+		newElement->elementSize = newElementSize;
+		
+		#ifdef ICNS_DEBUG
+		{
+			char typeStr[5];
+			printf(" updated element data...\n");
+			printf("  type: '%s'\n",icns_type_str(newElementType,typeStr));
+			printf("  size: %d\n",(int)newElementSize);
+		}
+		#endif		
+		
+		// Copy in the image data
+		memcpy(newElement->elementData,imageDataPtr,imageDataSize);
+		
+		// Free the old element...
+		if(*iconElement != NULL)
+			free(*iconElement);
+		
+		// and move the pointer to the new element
+		*iconElement = newElement;
+	}
+	
+exception:
+	
+	// We might have allocated new memory earlier...
+	if(newDataPtr != NULL)
+	{
+		free(newDataPtr);
+		newDataPtr = NULL;
+	}
+	
+	return error;
+}

src/add-ons/translators/icns/libicns/icns_family.c

@@ -0,0 +1,111 @@
+/*
+File:       icns_family.c
+Copyright (C) 2001-2012 Mathew Eis <[email protected]>
+              2007 Thomas Lübking <[email protected]>
+              2002 Chenxiao Zhao <[email protected]>
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, 
+Boston, MA 02110-1301, USA.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "icns.h"
+#include "icns_internals.h"
+
+/***************************** icns_create_family **************************/
+
+int icns_create_family(icns_family_t **iconFamilyOut)
+{
+	icns_family_t	*newIconFamily = NULL;
+	icns_type_t		iconFamilyType = ICNS_NULL_TYPE;
+	icns_size_t		iconFamilySize = 0;
+
+	if(iconFamilyOut == NULL)
+	{
+		icns_print_err("icns_create_family: icon family reference is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	*iconFamilyOut = NULL;
+	
+	iconFamilyType = ICNS_FAMILY_TYPE;
+	iconFamilySize = sizeof(icns_type_t) + sizeof(icns_size_t);
+
+	newIconFamily = malloc(iconFamilySize);
+		
+	if(newIconFamily == NULL)
+	{
+		icns_print_err("icns_create_family: Unable to allocate memory block of size: %d!\n",iconFamilySize);
+		return ICNS_STATUS_NO_MEMORY;
+	}
+	
+	ICNS_WRITE_UNALIGNED(&(newIconFamily->resourceType), iconFamilyType, sizeof(icns_type_t));
+	ICNS_WRITE_UNALIGNED(&(newIconFamily->resourceSize), iconFamilySize, sizeof(icns_size_t));
+
+	*iconFamilyOut = newIconFamily;
+	
+	return ICNS_STATUS_OK;
+}
+
+
+/***************************** icns_count_elements_in_family **************************/
+
+int icns_count_elements_in_family(icns_family_t *iconFamily, icns_sint32_t *elementTotal)
+{
+	icns_type_t            iconFamilyType = ICNS_NULL_TYPE;
+	icns_size_t            iconFamilySize = 0;
+	icns_uint32_t          dataOffset = 0;
+	icns_uint32_t          elementCount = 0;
+
+	if(iconFamily == NULL)
+	{
+		icns_print_err("icns_count_elements_in_family: icns family is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+
+	if(elementTotal == NULL)
+	{
+		icns_print_err("icns_count_elements_in_family: element count ref is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+
+	ICNS_READ_UNALIGNED(iconFamilyType, &(iconFamily->resourceType),sizeof( icns_type_t));
+	ICNS_READ_UNALIGNED(iconFamilySize, &(iconFamily->resourceSize),sizeof( icns_size_t));
+	
+	dataOffset = sizeof(icns_type_t) + sizeof(icns_size_t);
+	
+	while( dataOffset < iconFamilySize )
+	{
+		icns_element_t	       *iconElement = NULL;
+		icns_size_t            elementSize = 0;
+
+		iconElement = ((icns_element_t*)(((char*)iconFamily)+dataOffset));
+		ICNS_READ_UNALIGNED(elementSize, &(iconElement->elementSize),sizeof( icns_size_t));
+		
+		elementCount++;
+
+		dataOffset += elementSize;
+	}
+
+	*elementTotal = elementCount;
+
+	return ICNS_STATUS_OK;
+}
+
+

src/add-ons/translators/icns/libicns/icns_image.c

@@ -0,0 +1,794 @@
+/*
+File:       icns_image.c
+Copyright (C) 2001-2012 Mathew Eis <[email protected]>
+              2007 Thomas Lübking <[email protected]>
+              2002 Chenxiao Zhao <[email protected]>
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, 
+Boston, MA 02110-1301, USA.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "icns.h"
+#include "icns_internals.h"
+#include "icns_colormaps.h"
+
+
+int icns_get_image32_with_mask_from_family(icns_family_t *iconFamily,icns_type_t iconType,icns_image_t *imageOut)
+{
+	int		error = ICNS_STATUS_OK;
+	icns_type_t	maskType = ICNS_NULL_TYPE;
+	icns_element_t	*iconElement = NULL;
+	icns_element_t	*maskElement = NULL;
+	icns_image_t	iconImage;
+	icns_image_t	maskImage;
+	unsigned long	dataCount = 0;
+	icns_byte_t	dataValue = 0;
+	unsigned long	pixelCount = 0;
+	unsigned long	pixelID = 0;
+	icns_byte_t	colorIndex = 0;	
+	
+	memset ( &iconImage, 0, sizeof(icns_image_t) );
+	memset ( &maskImage, 0, sizeof(icns_image_t) );
+	
+	if(iconFamily == NULL)
+	{
+		icns_print_err("icns_get_image32_with_mask_from_family: Icon family is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	if(imageOut == NULL)
+	{
+		icns_print_err("icns_get_image32_with_mask_from_family: Icon image is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	else
+	{
+		icns_free_image(imageOut);
+	}
+	
+	#ifdef ICNS_DEBUG
+	{
+		char typeStr[5];
+		printf("Making 32-bit image...\n");
+		printf("  using icon type '%s'\n",icns_type_str(iconType,typeStr));
+	}
+	#endif
+	
+	
+	if((iconType == ICNS_128X128_8BIT_MASK) || \
+	(iconType == ICNS_48x48_8BIT_MASK) || \
+	(iconType == ICNS_32x32_8BIT_MASK) || \
+	(iconType == ICNS_16x16_8BIT_MASK) )
+	{
+		icns_print_err("icns_get_image32_with_mask_from_family: Can't make an image with mask from a mask\n");
+		return ICNS_STATUS_INVALID_DATA;
+	}
+	
+	// Preliminaries checked - carry on with the icon/mask merge
+	
+	// Load icon element then image
+	error = icns_get_element_from_family(iconFamily,iconType,&iconElement);
+	
+	if(error) {
+		icns_print_err("icns_get_image32_with_mask_from_family: Unable to load icon element from icon family!\n");
+		goto cleanup;
+	}
+	
+	error = icns_get_image_from_element(iconElement,&iconImage);
+	
+	if(error) {
+		icns_print_err("icns_get_image32_with_mask_from_family: Unable to load icon image data from icon element!\n");
+		goto cleanup;
+	}
+	
+	// We used the jp2 processor for these two, so we're done!
+	if( (iconType == ICNS_256x256_32BIT_ARGB_DATA) || (iconType == ICNS_512x512_32BIT_ARGB_DATA) || (iconType == ICNS_1024x1024_32BIT_ARGB_DATA) ) {
+		memcpy(imageOut,&iconImage,sizeof(icns_image_t));
+		if(iconElement != NULL) {
+		free(iconElement);
+		iconElement = NULL;
+		}
+		return error;
+	}
+	
+	maskType = icns_get_mask_type_for_icon_type(iconType);
+	
+	#ifdef ICNS_DEBUG
+	{
+		char typeStr[5];
+		printf("  using mask type '%s'\n",icns_type_str(maskType,typeStr));
+	}
+	#endif
+	
+	if( (maskType == ICNS_NULL_DATA) )
+	{
+		char typeStr[5];
+		icns_print_err("icns_get_image32_with_mask_from_family: Can't find mask for type '%s'\n",icns_type_str(iconType,typeStr));
+		return ICNS_STATUS_DATA_NOT_FOUND;
+	}
+	
+	// Load mask element then image...
+	error = icns_get_element_from_family(iconFamily,maskType,&maskElement);
+	
+	// Note that we could arguably recover from not having a mask
+	// by creating a dummy blank mask. However, the icns data type
+	// should always have the corresponding mask present. This
+	// function was designed to retreive a VALID image... There are
+	// other API functions better used if the goal is editing, data
+	// recovery, etc.
+	if(error) {
+		icns_print_err("icns_get_image32_with_mask_from_family: Unable to load mask element from icon family!\n");
+		goto cleanup;
+	}
+	
+	error = icns_get_mask_from_element(maskElement,&maskImage);
+	
+	if(error) {
+		icns_print_err("icns_get_image32_with_mask_from_family: Unable to load mask image data from icon element!\n");
+		goto cleanup;
+	}
+	
+	if(iconImage.imageWidth != maskImage.imageWidth) {
+		icns_print_err("icns_get_image32_with_mask_from_family: icon and mask widths do not match! (%d != %d)\n",iconImage.imageWidth,maskImage.imageHeight);
+		goto cleanup;
+	}
+	
+	if(iconImage.imageHeight != maskImage.imageHeight) {
+		icns_print_err("icns_get_image32_with_mask_from_family: icon and mask heights do not match! (%d != %d)\n",iconImage.imageHeight,maskImage.imageHeight);
+		goto cleanup;
+	}
+	
+	// Unpack image pixels if depth is < 32
+	if((iconImage.imagePixelDepth * iconImage.imageChannels) < 32)
+	{
+		icns_byte_t	*oldData = NULL;
+		icns_byte_t	*newData = NULL;
+		icns_uint32_t	oldBitDepth = 0;
+		unsigned long	newBlockSize = 0;
+		unsigned long	newDataSize = 0;
+		icns_colormap_rgb_t	colorRGB;
+		
+		oldBitDepth = (iconImage.imagePixelDepth * iconImage.imageChannels);
+		
+		pixelCount = iconImage.imageWidth * iconImage.imageHeight;
+		
+		newBlockSize = iconImage.imageWidth * 32;
+		newDataSize = newBlockSize * iconImage.imageHeight;
+		
+		oldData = iconImage.imageData;
+		newData = (icns_byte_t *)malloc(newDataSize);
+		
+		if(newData == NULL)
+		{
+			icns_print_err("icns_get_image32_with_mask_from_family: Unable to allocate memory block of size: %d!\n",(int)newDataSize);
+			return ICNS_STATUS_NO_MEMORY;
+		}
+		
+		dataCount = 0;
+		
+		// 8-Bit Icon Image Data Types
+		if((iconType == ICNS_48x48_8BIT_DATA) || \
+		(iconType == ICNS_32x32_8BIT_DATA) || \
+		(iconType == ICNS_16x16_8BIT_DATA) || \
+		(iconType == ICNS_16x12_8BIT_DATA) )
+		{
+			if(oldBitDepth != 8)
+			{
+				icns_print_err("icns_get_image32_with_mask_from_family: Invalid bit depth - type mismatch!\n");
+				free(newData);
+				error = ICNS_STATUS_INVALID_DATA;
+				goto cleanup;
+			}
+			for(pixelID = 0; pixelID < pixelCount; pixelID++)
+			{
+				colorIndex = oldData[dataCount++];
+				colorRGB = icns_colormap_8[colorIndex];
+				newData[pixelID * 4 + 0] = colorRGB.r;
+				newData[pixelID * 4 + 1] = colorRGB.g;
+				newData[pixelID * 4 + 2] = colorRGB.b;
+				newData[pixelID * 4 + 3] = 0xff;
+			}
+		}
+		// 4-Bit Icon Image Data Types
+		else if((iconType == ICNS_48x48_4BIT_DATA) || \
+		(iconType == ICNS_32x32_4BIT_DATA) || \
+		(iconType == ICNS_16x16_4BIT_DATA) || \
+		(iconType == ICNS_16x12_4BIT_DATA) )
+		{
+			if(oldBitDepth != 4)
+			{
+				icns_print_err("icns_get_image32_with_mask_from_family: Invalid bit depth - type mismatch!\n");
+				free(newData);
+				error = ICNS_STATUS_INVALID_DATA;
+				goto cleanup;
+			}
+			for(pixelID = 0; pixelID < pixelCount; pixelID++)
+			{
+				if(pixelID % 2 == 0)
+					dataValue = oldData[dataCount++];
+				colorIndex = (dataValue & 0xF0) >> 4;
+				dataValue = dataValue << 4;
+				colorRGB = icns_colormap_4[colorIndex];
+				newData[pixelID * 4 + 0] = colorRGB.r;
+				newData[pixelID * 4 + 1] = colorRGB.g;
+				newData[pixelID * 4 + 2] = colorRGB.b;
+				newData[pixelID * 4 + 3] = 0xFF;
+			}
+		}
+		// 1-Bit Icon Image Data Types
+		else if((iconType == ICNS_48x48_1BIT_DATA) || \
+		(iconType == ICNS_32x32_1BIT_DATA) || \
+		(iconType == ICNS_16x16_1BIT_DATA) || \
+		(iconType == ICNS_16x12_1BIT_DATA) )
+		{
+			if(oldBitDepth != 1)
+			{
+				icns_print_err("icns_get_image32_with_mask_from_family: Invalid bit depth - type mismatch!\n");
+				free(newData);
+				error = ICNS_STATUS_INVALID_DATA;
+				goto cleanup;
+			}
+			for(pixelID = 0; pixelID < pixelCount; pixelID++)
+			{
+				if(pixelID % 8 == 0)
+					dataValue = oldData[dataCount++];
+				colorIndex = (dataValue & 0x80) ? 0x00 : 0xFF;
+				dataValue = dataValue << 1;
+				newData[pixelID * 4 + 0] = colorIndex;
+				newData[pixelID * 4 + 1] = colorIndex;
+				newData[pixelID * 4 + 2] = colorIndex;
+				newData[pixelID * 4 + 3] = 0xFF;
+			}
+		}
+		else
+		{
+			char typeStr[5];
+			icns_print_err("icns_get_image32_with_mask_from_family: Unpack error - unknown icon type! ('%s')\n",icns_type_str(iconType,typeStr));
+			free(newData);
+			error = ICNS_STATUS_INVALID_DATA;
+			goto cleanup;
+		}
+		
+		iconImage.imagePixelDepth = 8;
+		iconImage.imageChannels = 4;
+		iconImage.imageDataSize = newDataSize;
+		iconImage.imageData = newData;
+		
+		free(oldData);
+	}
+	
+	// 8-Bit Icon Mask Data Types
+	if((maskType == ICNS_128X128_8BIT_MASK) || \
+	(maskType == ICNS_48x48_8BIT_MASK) || \
+	(maskType == ICNS_32x32_8BIT_MASK) || \
+	(maskType == ICNS_16x16_8BIT_MASK) )
+	{
+		pixelCount = maskImage.imageWidth * maskImage.imageHeight;
+		dataCount = 0;
+		if((maskImage.imagePixelDepth * maskImage.imageChannels) != 8)
+		{
+			icns_print_err("icns_get_image32_with_mask_from_family: Invalid bit depth - mismatch!\n");
+			error = ICNS_STATUS_INVALID_DATA;
+			goto cleanup;
+		}
+		for(pixelID = 0; pixelID < pixelCount; pixelID++)
+		{
+			iconImage.imageData[pixelID * 4 + 3] = maskImage.imageData[dataCount++];
+		}
+	}
+	// 1-Bit Icon Mask Data Types
+	else if((maskType == ICNS_48x48_1BIT_MASK) || \
+	(maskType == ICNS_32x32_1BIT_MASK) || \
+	(maskType == ICNS_16x16_1BIT_MASK) || \
+	(maskType == ICNS_16x12_1BIT_MASK) )
+	{
+		pixelCount = maskImage.imageWidth * maskImage.imageHeight;
+		dataCount = 0;
+		if((maskImage.imagePixelDepth * maskImage.imageChannels) != 1)
+		{
+			icns_print_err("icns_get_image32_with_mask_from_family: Invalid bit depth - mismatch!\n");
+			error = ICNS_STATUS_INVALID_DATA;
+			goto cleanup;
+		}
+		for(pixelID = 0; pixelID < pixelCount; pixelID++)
+		{
+			if(pixelID % 8 == 0)
+				dataValue = maskImage.imageData[dataCount++];
+			colorIndex = (dataValue & 0x80) ? 0xFF : 0x00;
+			dataValue = dataValue << 1;
+			iconImage.imageData[pixelID * 4 + 3] = colorIndex;
+		}
+	}
+	else
+	{		
+		char typeStr[5];
+		icns_print_err("icns_get_image32_with_mask_from_family: Unpack error - unknown mask type! ('%s')\n",icns_type_str(maskType,typeStr));
+		error = ICNS_STATUS_INVALID_DATA;
+		goto cleanup;
+	}
+	
+cleanup:
+	
+	if(maskElement != NULL) {
+		free(maskElement);
+		maskElement = NULL;
+	}
+	icns_free_image(&maskImage);
+	
+	if(iconElement != NULL) {
+		free(iconElement);
+		iconElement = NULL;
+	}
+	
+	// We only free the icon image if there was an error. Otherwise, we
+	// pass the data onto the outgoing image
+	if(error) {
+		icns_free_image(&iconImage);
+	} else {
+		memcpy(imageOut,&iconImage,sizeof(icns_image_t));
+		#ifdef ICNS_DEBUG
+		printf("Finished 32-bit image...\n");
+		printf("  height: %d\n",imageOut->imageHeight);
+		printf("  width: %d\n",imageOut->imageHeight);
+		printf("  channels: %d\n",imageOut->imageChannels);
+		printf("  pixel depth: %d\n",imageOut->imagePixelDepth);
+		printf("  data size: %d\n",(int)(imageOut->imageDataSize));
+		#endif
+	}
+	
+	return error;
+}
+
+
+//***************************** icns_get_image_from_element **************************//
+// Actual conversion of the icon data into uncompressed raw pixels
+
+int icns_get_image_from_element(icns_element_t *iconElement,icns_image_t *imageOut)
+{
+	int		error = ICNS_STATUS_OK;
+	unsigned long	dataCount = 0;
+	icns_type_t	elementType = ICNS_NULL_TYPE;
+	icns_size_t	elementSize = 0;
+	icns_type_t	iconType = ICNS_NULL_TYPE;
+	unsigned long	rawDataSize = 0;
+	icns_byte_t	*rawDataPtr = NULL;
+	icns_uint32_t	iconBitDepth = 0;
+	unsigned long	iconDataRowSize = 0;
+	
+	if(iconElement == NULL)
+	{
+		icns_print_err("icns_get_image_from_element: Icon element is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	if(imageOut == NULL)
+	{
+		icns_print_err("icns_get_image_from_element: Icon image structure is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	elementType = iconElement->elementType;
+	elementSize = iconElement->elementSize;
+	
+	#if ICNS_DEBUG
+	{
+		char typeStr[5];
+		printf("Retreiving image from icon element...\n");
+		printf("  type is: '%s'\n",icns_type_str(elementType,typeStr));
+		printf("  size is: %d\n",(int)elementSize);
+	}	
+	#endif
+	
+	if(elementSize <= 8)
+	{
+		icns_print_err("icns_get_image_from_element: Invalid element size! (%d)\n",elementSize);
+		return ICNS_STATUS_INVALID_DATA;
+	}
+	
+	iconType = elementType;
+	rawDataSize = elementSize - sizeof(icns_type_t) - sizeof(icns_size_t);
+	rawDataPtr = (icns_byte_t*)&(iconElement->elementData[0]);
+	
+	#if ICNS_DEBUG
+	printf("  data size is: %d\n",(int)rawDataSize);
+	#endif
+	
+	switch(iconType)
+	{
+		// 32-Bit Icon Image Data Types ( > 256px )
+		case ICNS_256x256_32BIT_ARGB_DATA:
+		case ICNS_512x512_32BIT_ARGB_DATA:
+		case ICNS_1024x1024_32BIT_ARGB_DATA:
+			{
+				uint8_t magicPNG[] = {0x89,0x50,0x4E,0x47,0x0D,0x0A,0x1A,0x0A};
+				uint8_t magicByt[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}; 
+			
+				ICNS_READ_UNALIGNED(magicByt[0], rawDataPtr, 8);
+				
+				// 256x256+ sizes may or may not be PNG dta as of 10.7 Lion, so check
+				if(memcmp(&magicByt[0], &magicPNG[0], 8) == 0) {
+					// We know to use the PNG processor
+					error = icns_png_to_image((int)rawDataSize, (icns_byte_t *)rawDataPtr, imageOut);
+				} else {
+					// We assume use of the jp2 processor
+					error = icns_jp2_to_image((int)rawDataSize, (icns_byte_t *)rawDataPtr, imageOut);
+				}
+				return error;
+			}
+		case ICNS_128X128_32BIT_DATA:
+		case ICNS_48x48_32BIT_DATA:
+		case ICNS_32x32_32BIT_DATA:
+		case ICNS_16x16_32BIT_DATA:
+
+			error = icns_init_image_for_type(iconType,imageOut);
+			if(error)
+			{
+				icns_print_err("icns_get_image_from_element: Error allocating new icns image!\n");
+				icns_free_image(imageOut);
+				return error;
+			}
+			
+			iconBitDepth = imageOut->imagePixelDepth * imageOut->imageChannels;
+			iconDataRowSize = imageOut->imageWidth * iconBitDepth / ICNS_BYTE_BITS;
+			
+			if(rawDataSize < imageOut->imageDataSize)
+			{
+				icns_uint32_t	pixelCount = 0;
+				icns_size_t	decodedDataSize = imageOut->imageDataSize;
+				icns_byte_t	*decodedImageData = imageOut->imageData;
+	
+				pixelCount = imageOut->imageWidth * imageOut->imageHeight;
+				error = icns_decode_rle24_data(rawDataSize,rawDataPtr,pixelCount,&decodedDataSize,&decodedImageData);
+				if(error)
+				{
+					icns_print_err("icns_get_image_from_element: Error decoding RLE data!\n");
+					icns_free_image(imageOut);
+					return error;
+				}
+				else
+				{
+					imageOut->imageDataSize = decodedDataSize;
+					imageOut->imageData = decodedImageData;
+				}
+			}
+			else
+			{
+				unsigned long	pixelCount = 0;
+				icns_byte_t	*swapPtr = NULL;
+				icns_argb_t	*pixelPtr = NULL;
+	
+				for(dataCount = 0; dataCount < imageOut->imageHeight; dataCount++)
+					memcpy(&(((char*)(imageOut->imageData))[dataCount*iconDataRowSize]),&(((char*)(rawDataPtr))[dataCount*iconDataRowSize]),iconDataRowSize);
+				
+				pixelCount = imageOut->imageWidth * imageOut->imageHeight;
+				#ifdef ICNS_DEBUG
+					printf("Converting %d pixels from argb to rgba\n",(int)pixelCount);
+				#endif
+				swapPtr = imageOut->imageData;
+				for(dataCount = 0; dataCount < pixelCount; dataCount++)
+				{
+					pixelPtr = (icns_argb_t *)(swapPtr + (dataCount * 4));
+					*((icns_rgba_t *)pixelPtr) = ICNS_ARGB_TO_RGBA( *((icns_argb_t *)pixelPtr) );
+				}
+			}
+			break;
+		case ICNS_48x48_8BIT_DATA:
+		case ICNS_32x32_8BIT_DATA:
+		case ICNS_16x16_8BIT_DATA:
+		case ICNS_16x12_8BIT_DATA:
+		case ICNS_48x48_4BIT_DATA:
+		case ICNS_32x32_4BIT_DATA:
+		case ICNS_16x16_4BIT_DATA:
+		case ICNS_16x12_4BIT_DATA:
+		case ICNS_48x48_1BIT_DATA:
+		case ICNS_32x32_1BIT_DATA:
+		case ICNS_16x16_1BIT_DATA:
+		case ICNS_16x12_1BIT_DATA:
+
+			error = icns_init_image_for_type(iconType,imageOut);
+			if(error)
+			{
+				icns_print_err("icns_get_image_from_element: Error allocating new icns image!\n");
+				icns_free_image(imageOut);
+				return error;
+			}
+			
+			iconBitDepth = imageOut->imagePixelDepth * imageOut->imageChannels;
+			iconDataRowSize = imageOut->imageWidth * iconBitDepth / ICNS_BYTE_BITS;
+			
+			for(dataCount = 0; dataCount < imageOut->imageHeight; dataCount++)
+				memcpy(&(((char*)(imageOut->imageData))[dataCount*iconDataRowSize]),&(((char*)(rawDataPtr))[dataCount*iconDataRowSize]),iconDataRowSize);
+			break;
+		default:
+			{
+				char typeStr[5];
+				icns_print_err("icns_get_image_from_element: Unknown icon type! ('%s')\n",icns_type_str(iconType,typeStr));
+				icns_free_image(imageOut);
+			}
+			return ICNS_STATUS_INVALID_DATA;
+	}
+	
+	return error;
+}
+
+//***************************** icns_get_mask_from_element **************************//
+// Actual conversion of the mask data into uncompressed raw pixels
+
+int icns_get_mask_from_element(icns_element_t *maskElement,icns_image_t *imageOut)
+{
+	int		error = ICNS_STATUS_OK;
+	unsigned long	dataCount = 0;
+	icns_type_t	elementType = ICNS_NULL_TYPE;
+	icns_size_t	elementSize = 0;
+	icns_type_t	maskType = ICNS_NULL_TYPE;
+	unsigned long	rawDataSize = 0;
+	icns_byte_t	*rawDataPtr = NULL;
+	icns_uint32_t	maskBitDepth = 0;
+	unsigned long	maskDataSize = 0;
+	unsigned long	maskDataRowSize = 0;
+			
+	if(maskElement == NULL)
+	{
+		icns_print_err("icns_get_mask_from_element: Mask element is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	if(imageOut == NULL)
+	{
+		icns_print_err("icns_get_mask_from_element: Mask image structure is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	elementType = maskElement->elementType;
+	elementSize = maskElement->elementSize;
+	
+	#if ICNS_DEBUG
+	{
+		char typeStr[5];
+		printf("Retreiving image from mask element...\n");
+		printf("  type is: '%s'\n",icns_type_str(elementType,typeStr));
+		printf("  size is: %d\n",(int)elementSize);
+	}
+	#endif
+	
+	if(elementSize <= 8)
+	{
+		icns_print_err("icns_get_image_from_element: Invalid element size! (%d)\n",elementSize);
+		return ICNS_STATUS_INVALID_DATA;
+	}
+	
+	maskType = elementType;
+	rawDataSize = elementSize - sizeof(icns_type_t) - sizeof(icns_size_t);
+	rawDataPtr = (icns_byte_t*)&(maskElement->elementData[0]);
+	
+	#if ICNS_DEBUG
+	printf("  data size is: %d\n",(int)rawDataSize);	
+	#endif
+
+	switch(maskType)
+	{
+		case ICNS_128X128_8BIT_MASK:
+		case ICNS_48x48_8BIT_MASK:
+		case ICNS_32x32_8BIT_MASK:
+		case ICNS_16x16_8BIT_MASK:
+
+			error = icns_init_image_for_type(maskType,imageOut);
+			if(error)
+			{
+				icns_print_err("icns_get_mask_from_element: Error allocating new icns image!\n");
+				icns_free_image(imageOut);
+				return error;
+			}
+			
+			maskBitDepth = imageOut->imagePixelDepth * imageOut->imageChannels;
+			
+			if(maskBitDepth != 8) {
+				icns_print_err("icns_get_mask_from_element: Unknown bit depth!\n");
+				icns_free_image(imageOut);
+				return ICNS_STATUS_INVALID_DATA;
+			}
+			
+			maskDataSize = imageOut->imageDataSize;
+			maskDataRowSize = imageOut->imageWidth * maskBitDepth / ICNS_BYTE_BITS;
+			
+			for(dataCount = 0; dataCount < imageOut->imageHeight; dataCount++)
+				memcpy(&(((char*)(imageOut->imageData))[dataCount*maskDataRowSize]),&(((char*)(rawDataPtr))[dataCount*maskDataRowSize]),maskDataRowSize);
+
+			break;
+		case ICNS_48x48_1BIT_MASK:
+		case ICNS_32x32_1BIT_MASK:
+		case ICNS_16x16_1BIT_MASK:
+		case ICNS_16x12_1BIT_MASK:
+
+			error = icns_init_image_for_type(maskType,imageOut);
+			if(error)
+			{
+				icns_print_err("icns_get_mask_from_element: Error allocating new icns image!\n");
+				icns_free_image(imageOut);
+				return error;
+			}
+	
+			maskBitDepth = imageOut->imagePixelDepth * imageOut->imageChannels;
+			
+			if(maskBitDepth != 1) {
+				icns_print_err("icns_get_mask_from_element: Unknown bit depth!\n");
+				icns_free_image(imageOut);
+				return ICNS_STATUS_INVALID_DATA;
+			}
+			
+			maskDataSize = imageOut->imageDataSize;
+			maskDataRowSize = imageOut->imageWidth * maskBitDepth / ICNS_BYTE_BITS;
+			
+			#if ICNS_DEBUG
+			printf("  raw mask data size is: %d\n",(int)rawDataSize);	
+			printf("  image mask data size is: %d\n",(int)maskDataSize);	
+			#endif
+	
+			if(rawDataSize == (maskDataSize * 2) )
+			{
+				#if ICNS_DEBUG
+				printf("  mask data in second memory block\n");	
+				#endif					
+				// Mask data found - Copy the second block of memory
+				for(dataCount = 0; dataCount < imageOut->imageHeight; dataCount++)
+					memcpy(&(((char*)(imageOut->imageData))[dataCount*maskDataRowSize]),&(((char*)(rawDataPtr))[dataCount*maskDataRowSize+maskDataSize]),maskDataRowSize);
+			}
+			else
+			{
+				#if ICNS_DEBUG
+				printf("  using icon data from first memory block\n");	
+				#endif					
+				// Hmm, no mask - copy the first block of memory
+				for(dataCount = 0; dataCount < imageOut->imageHeight; dataCount++)
+					memcpy(&(((char*)(imageOut->imageData))[dataCount*maskDataRowSize]),&(((char*)(rawDataPtr))[dataCount*maskDataRowSize]),maskDataRowSize);
+			}
+			
+			break;
+		default:
+			{
+				char typeStr[5];
+				icns_print_err("icns_get_mask_from_element: Unknown mask type! ('%s')\n",icns_type_str(maskType,typeStr));
+				icns_free_image(imageOut);
+			}
+			return ICNS_STATUS_INVALID_DATA;
+	}
+	
+	return error;
+}
+
+
+
+//***************************** icns_init_image_for_type **************************//
+// Initialize a new image structure for holding the data
+// using the information for the specified type
+
+int icns_init_image_for_type(icns_type_t iconType,icns_image_t *imageOut)
+{
+	icns_icon_info_t iconInfo;
+	
+	if(imageOut == NULL)
+	{
+		icns_print_err("icns_init_image_for_type: Icon image structure is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	// Determine what the height and width ought to be, to check the incoming image
+	
+	iconInfo = icns_get_image_info_for_type(iconType);
+	
+	if(iconType != iconInfo.iconType)
+	{
+		char typeStr[5];
+		icns_print_err("icns_init_image_for_type: Couldn't determine information for type! ('%s')\n",icns_type_str(iconType,typeStr));
+		return ICNS_STATUS_INVALID_DATA;
+	}
+	
+	return icns_init_image(iconInfo.iconWidth,iconInfo.iconHeight,iconInfo.iconChannels,iconInfo.iconPixelDepth,imageOut);
+
+}
+
+//***************************** icns_init_image **************************//
+// Initialize a new image structure for holding the data
+
+int icns_init_image(icns_uint32_t iconWidth,icns_uint32_t iconHeight,icns_uint32_t iconChannels,icns_uint32_t iconPixelDepth,icns_image_t *imageOut)
+{
+	icns_uint32_t	iconBitDepth = 0;
+	unsigned long	iconDataSize = 0;
+	unsigned long	iconDataRowSize = 0;
+
+	if(imageOut == NULL)
+	{
+		icns_print_err("icns_init_image: Icon image structure is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+
+	if(iconWidth == 0)
+	{
+		icns_print_err("icns_init_image: icon width is 0!\n");
+		return ICNS_STATUS_INVALID_DATA;
+	}
+
+	if(iconHeight == 0)
+	{
+		icns_print_err("icns_init_image: icon height is 0!\n");
+		return ICNS_STATUS_INVALID_DATA;
+	}
+
+	if(iconChannels == 0)
+	{
+		icns_print_err("icns_init_image: icon channels is 0!\n");
+		return ICNS_STATUS_INVALID_DATA;
+	}
+
+	if(iconPixelDepth == 0)
+	{
+		icns_print_err("icns_init_image: icon pixel depth is 0!\n");
+		return ICNS_STATUS_INVALID_DATA;
+	}
+
+	iconBitDepth = iconPixelDepth * iconChannels;
+	iconDataRowSize = iconWidth * iconBitDepth / ICNS_BYTE_BITS;
+	iconDataSize = iconHeight * iconDataRowSize;
+	
+	#ifdef ICNS_DEBUG
+	printf("Initializing new image...\n");
+	printf("  width is: %d\n",iconWidth);
+	printf("  height is: %d\n",iconHeight);
+	printf("  channels are: %d\n",iconChannels);
+	printf("  bit depth is: %d\n",iconBitDepth);
+	printf("  data size is: %d\n",(int)iconDataSize);
+	#endif
+	
+	imageOut->imageWidth = iconWidth;
+	imageOut->imageHeight = iconHeight;
+	imageOut->imageChannels = iconChannels;
+	imageOut->imagePixelDepth = (iconBitDepth / iconChannels);
+	imageOut->imageDataSize = iconDataSize;
+	imageOut->imageData = (icns_byte_t *)malloc(iconDataSize);
+	if(!imageOut->imageData)
+	{
+		icns_print_err("icns_init_image: Unable to allocate memory block of size: %d ($s:%m)!\n",(int)iconDataSize);
+		return ICNS_STATUS_NO_MEMORY;
+	}
+	memset(imageOut->imageData,0,iconDataSize);
+	
+	return ICNS_STATUS_OK;
+}
+
+//***************************** icns_free_image **************************//
+// Deallocate data in an image structure
+
+int icns_free_image(icns_image_t *imageIn)
+{
+	imageIn->imageWidth = 0;
+	imageIn->imageHeight = 0;
+	imageIn->imageChannels = 0;
+	imageIn->imagePixelDepth = 0;
+	imageIn->imageDataSize = 0;
+	
+	if(imageIn->imageData != NULL)
+	{
+		free(imageIn->imageData);
+		imageIn->imageData = NULL;
+	}
+	
+	return ICNS_STATUS_OK;
+}
+

src/add-ons/translators/icns/libicns/icns_internals.h

@@ -0,0 +1,207 @@
+/*
+File:       icns.h
+Copyright (C) 2001-2012 Mathew Eis <[email protected]>
+Copyright (C) 2002 Chenxiao Zhao <[email protected]>
+
+With the exception of the limited portions mentiond, this library
+is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published
+by the Free Software Foundation; either version 2.1 of the License,
+or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, 
+Boston, MA 02110-1301, USA.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "icns.h"
+
+#include "config.h"
+
+#ifndef _ICNS_INTERNALS_H_
+#define	_ICNS_INTERNALS_H_
+
+/*  Compile-time variables   */
+/*  These should really be set from the Makefile */
+
+// Enable debugging messages?
+// #define	ICNS_DEBUG	1
+
+// Enable supprt for 256x256, 512x512 and 1024x1024 icons
+// Use either Jasper or OpenJPEG, but not both
+// #define	ICNS_JASPER
+// #define	ICNS_OPENJPEG
+
+/* Make sure we're not using both libraries */
+#if defined(ICNS_JASPER) && defined(ICNS_OPENJPEG)
+	#error "Must use either Jasper or OpenJPEG, but not both!"
+#endif
+
+/*  Include Jasper headers   */
+#ifdef ICNS_JASPER
+#include <jasper.h>
+#endif
+
+/*  Include OpenJPEG headers   */
+#ifdef ICNS_OPENJPEG
+#include <openjpeg.h>
+#endif
+
+// We do not want to expose any of the internal stuff
+#pragma GCC visibility push(hidden)
+
+/* icns structures */
+
+typedef struct icns_rgba_t
+{
+	icns_byte_t	 r;
+	icns_byte_t	 g;
+	icns_byte_t	 b;
+	icns_byte_t	 a;
+} icns_rgba_t;
+
+typedef struct icns_argb_t
+{
+	icns_byte_t	 a;
+	icns_byte_t	 r;
+	icns_byte_t	 g;
+	icns_byte_t	 b;
+} icns_argb_t;
+
+typedef struct icns_rgb_t
+{
+	icns_byte_t	 r;
+	icns_byte_t	 g;
+	icns_byte_t	 b;
+} icns_rgb_t;
+
+/* icns constants */
+
+
+typedef enum icns_rsrc_endian_t
+{
+	ICNS_BE_RSRC = 0,
+	ICNS_LE_RSRC = 1
+} icns_rsrc_endian_t;
+
+#define	ICNS_BYTE_BITS	                  8
+
+#define ICNS_APPLE_SINGLE_MAGIC           0x00051600
+#define	ICNS_APPLE_DOUBLE_MAGIC           0x00051607
+
+#define	ICNS_APPLE_ENC_DATA               1
+#define	ICNS_APPLE_ENC_RSRC               2
+
+/* icns macros */
+
+/*
+These functions swap the position of the alpha channel
+*/
+static inline icns_rgba_t ICNS_ARGB_TO_RGBA(icns_argb_t pxin) {
+	icns_rgba_t pxout;
+	pxout.r = pxin.r;
+	pxout.g = pxin.g;
+	pxout.b = pxin.b;
+	pxout.a = pxin.a;
+	return pxout;
+}
+
+static inline icns_argb_t ICNS_RGBA_TO_ARGB(icns_rgba_t pxin) {
+	icns_argb_t pxout;
+	pxout.r = pxin.r;
+	pxout.g = pxin.g;
+	pxout.b = pxin.b;
+	pxout.a = pxin.a;
+	return pxout;
+}
+
+/*
+These macros will work on systems that support unaligned
+accesses, as well as those that don't support it.
+Unfortunately, gcc doesn't support unaligned access well
+with memcpy on some architectures due to a combination of
+memcpy being inlined during the optimization process and
+memory alignment. So, we try to work around this here.
+*/
+
+// If the autotools didn't tell us, try and make a good guess
+#ifndef HAVE_UNALIGNED_MEMCPY
+ #if defined(__GNUC__) && (defined(__arm__) || defined(__thumb__) || defined(__sparc__))
+  #define HAVE_UNALIGNED_MEMCPY 0
+ #else
+  #define HAVE_UNALIGNED_MEMCPY 1
+ #endif
+#endif
+
+// Set up the macros
+#if HAVE_UNALIGNED_MEMCPY == 0
+ __attribute__ ((noinline)) void *icns_memcpy( void *dst, const void *src, size_t num );
+ #define ICNS_READ_UNALIGNED(val, addr, size)        icns_memcpy(&(val), (addr), size)
+ #define ICNS_WRITE_UNALIGNED(addr, val, size)       icns_memcpy((addr), &(val), size)
+#else
+ #define ICNS_READ_UNALIGNED(val, addr, size)        memcpy(&(val), (addr), size)
+ #define ICNS_WRITE_UNALIGNED(addr, val, size)       memcpy((addr), &(val), size)
+#endif
+
+/* global variables */
+extern icns_bool_t gShouldPrintErrors;
+
+/* icns function prototypes */
+
+// icns_debug.c
+void bin_print_byte(int x);
+void bin_print_int(int x);
+
+// icns_element.c
+int icns_new_element_from_image_or_mask(icns_image_t *imageIn,icns_type_t iconType,icns_bool_t isMask,icns_element_t **iconElementOut);
+int icns_update_element_with_image_or_mask(icns_image_t *imageIn,icns_bool_t isMask,icns_element_t **iconElement);
+
+// icns_io.c
+int icns_parse_family_data(icns_size_t dataSize,icns_byte_t *data,icns_family_t **iconFamilyOut);
+int icns_find_family_in_mac_resource(icns_size_t resDataSize, icns_byte_t *resData, icns_rsrc_endian_t fileEndian, icns_family_t **dataOut);
+int icns_read_macbinary_resource_fork(icns_size_t dataSize,icns_byte_t *dataPtr,icns_type_t *dataTypeOut, icns_type_t *dataCreatorOut,icns_size_t *parsedResSizeOut,icns_byte_t **parsedResDataOut);
+int icns_read_apple_encoded_resource_fork(icns_size_t dataSize,icns_byte_t *dataPtr,icns_type_t *dataTypeOut, icns_type_t *dataCreatorOut,icns_size_t *parsedResSizeOut,icns_byte_t **parsedResDataOut);
+icns_bool_t icns_icns_header_check(icns_size_t dataSize,icns_byte_t *dataPtr);
+icns_bool_t icns_rsrc_header_check(icns_size_t dataSize,icns_byte_t *dataPtr,icns_rsrc_endian_t fileEndian);
+icns_bool_t icns_macbinary_header_check(icns_size_t dataSize,icns_byte_t *dataPtr);
+icns_bool_t icns_apple_encoded_header_check(icns_size_t dataSize,icns_byte_t *dataPtr);
+
+// icns_png.c
+int icns_image_to_png(icns_image_t *image, icns_size_t *dataSizeOut, icns_byte_t **dataPtrOut);
+int icns_png_to_image(icns_size_t dataSize, icns_byte_t *dataPtr, icns_image_t *imageOut);
+
+// icns_jp2.c
+#ifdef ICNS_JASPER
+int icns_jas_jp2_to_image(icns_size_t dataSize, icns_byte_t *dataPtr, icns_image_t *imageOut);
+int icns_jas_image_to_jp2(icns_image_t *image, icns_size_t *dataSizeOut, icns_byte_t **dataPtrOut);
+#endif
+#ifdef ICNS_OPENJPEG
+int icns_opj_jp2_to_image(icns_size_t dataSize, icns_byte_t *dataPtr, icns_image_t *imageOut);
+int icns_opj_jp2_dec(icns_size_t dataSize, icns_byte_t *dataPtr, opj_image_t **imageOut);
+int icns_opj_to_image(opj_image_t *image, icns_image_t *outIcon);
+int icns_opj_image_to_jp2(icns_image_t *image, icns_size_t *dataSizeOut, icns_byte_t **dataPtrOut);
+void icns_opj_error_callback(const char *msg, void *client_data);
+void icns_opj_warning_callback(const char *msg, void *client_data);
+void icns_opj_info_callback(const char *msg, void *client_data);
+#endif
+void icns_place_jp2_cdef(icns_byte_t *dataPtr, icns_size_t dataSize);
+
+// icns_utils.c
+icns_uint32_t icns_get_element_order(icns_type_t iconType);
+void icns_print_err(const char *template, ...);
+
+// Stop hiding symbols
+#pragma GCC visibility pop
+
+#endif /* _ICNS_INTERNALS_H_ */

src/add-ons/translators/icns/libicns/icns_jp2.c

@@ -0,0 +1,961 @@
+/*
+File:       icns_jp2.c
+Copyright (C) 2001-2012 Mathew Eis <[email protected]>
+              2007 Thomas Lübking <[email protected]>
+              2002 Chenxiao Zhao <[email protected]>
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, 
+Boston, MA 02110-1301, USA.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "icns.h"
+#include "icns_internals.h"
+
+#ifdef ICNS_JASPER
+#include <jasper.h>
+#endif
+
+#ifdef ICNS_OPENJPEG
+#include <openjpeg.h>
+#endif
+
+#define true 1
+#define false 0
+
+#if defined(ICNS_JASPER) && defined(ICNS_OPENJPEG)
+	#error "Should use either Jasper or OpenJPEG, but not both!"
+#endif
+
+
+int icns_jp2_to_image(icns_size_t dataSize, icns_byte_t *dataPtr, icns_image_t *imageOut)
+{
+	int error = ICNS_STATUS_OK;
+	
+	if(dataPtr == NULL)
+	{
+		icns_print_err("icns_jp2_to_image: JP2 data is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	if(imageOut == NULL)
+	{
+		icns_print_err("icns_jp2_to_image: Image out is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	if(dataSize == 0)
+	{
+		icns_print_err("icns_jp2_to_image: Invalid data size! (%d)\n",dataSize);
+		return ICNS_STATUS_INVALID_DATA;
+	}
+	
+	#ifdef ICNS_DEBUG
+	printf("Decoding JP2 image...\n");
+	#endif
+	
+	#ifdef ICNS_JASPER
+		error = icns_jas_jp2_to_image(dataSize, dataPtr, imageOut);	
+	#else
+	#ifdef ICNS_OPENJPEG
+		error = icns_opj_jp2_to_image(dataSize, dataPtr, imageOut);	
+	#else
+		icns_print_err("icns_jp2_to_image: libicns requires jasper or openjpeg to convert jp2 data!\n");
+		icns_free_image(imageOut);
+		error = ICNS_STATUS_UNSUPPORTED;
+	#endif
+	#endif
+	
+	#ifdef ICNS_DEBUG
+	if(error == ICNS_STATUS_OK) {
+		printf("  decode result:\n");
+		printf("  width is: %d\n",imageOut->imageWidth);
+		printf("  height is: %d\n",imageOut->imageHeight);
+		printf("  channels are: %d\n",imageOut->imageChannels);
+		printf("  pixel depth is: %d\n",imageOut->imagePixelDepth);
+		printf("  data size is: %d\n",(int)imageOut->imageDataSize);
+	} else {
+		printf("  decode failed.\n");
+	}
+	#endif
+	
+	return error;
+}
+
+
+int icns_image_to_jp2(icns_image_t *image, icns_size_t *dataSizeOut, icns_byte_t **dataPtrOut)
+{
+	int error = ICNS_STATUS_OK;
+	
+	if(image == NULL)
+	{
+		icns_print_err("icns_image_to_jp2: Image is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	if(dataSizeOut == NULL)
+	{
+		icns_print_err("icns_image_to_jp2: Data size NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	if(dataPtrOut == NULL)
+	{
+		icns_print_err("icns_image_to_jp2: Data ref is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	#ifdef ICNS_DEBUG
+	printf("Encoding JP2 image...\n");
+	#endif
+	
+	#ifdef ICNS_JASPER
+		error = icns_jas_image_to_jp2(image, dataSizeOut, dataPtrOut);	
+	#else
+	#ifdef ICNS_OPENJPEG
+		error = icns_opj_image_to_jp2(image, dataSizeOut, dataPtrOut);
+	#else
+		*dataPtrOut = NULL;
+		error = ICNS_STATUS_UNSUPPORTED;
+	#endif
+	#endif
+	
+	return error;
+}
+
+
+#ifdef ICNS_JASPER
+
+int icns_jas_jp2_to_image(icns_size_t dataSize, icns_byte_t *dataPtr, icns_image_t *imageOut)
+{
+	int           error = ICNS_STATUS_OK;
+	jas_stream_t  *imagestream = NULL;
+	int           datafmt = 0;
+	jas_image_t   *image = NULL;
+	jas_matrix_t  *bufs[4] = {NULL,NULL,NULL,NULL};
+	icns_sint32_t imageChannels = 0;
+	icns_sint32_t imageWidth = 0;
+	icns_sint32_t imageHeight = 0;
+	icns_sint32_t imagePixelDepth = 0;
+	icns_sint32_t imageDataSize = 0;
+	icns_byte_t   *imageData = NULL;
+	icns_sint8_t    adjust[4] = {0,0,0,0};
+	int x, y, c;
+	
+	if(dataPtr == NULL)
+	{
+		icns_print_err("icns_jas_jp2_to_image: JP2 data is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	if(imageOut == NULL)
+	{
+		icns_print_err("icns_jas_jp2_to_image: Image out is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	if(dataSize == 0)
+	{
+		icns_print_err("icns_jas_jp2_to_image: Invalid data size! (%d)\n",dataSize);
+		return ICNS_STATUS_INVALID_DATA;
+	}
+	
+	jas_init();
+	
+	// Connect a jasper stream to the memory
+	imagestream = jas_stream_memopen((char*)dataPtr, dataSize);
+	
+	if(imagestream == NULL)
+	{
+		icns_print_err("icns_jas_jp2_to_image: Unable to connect to buffer for decoding!\n");
+		return ICNS_STATUS_INVALID_DATA;
+	}
+	
+	// Determine the image format
+	datafmt = jas_image_getfmt(imagestream);
+	
+	if(datafmt < 0)
+	{
+		icns_print_err("icns_jas_jp2_to_image: Unable to determine jp2 data format! (%d)\n",datafmt);
+		jas_stream_close(imagestream);
+		return ICNS_STATUS_INVALID_DATA;
+	}
+	
+	//.Decode the image data
+	// WARNING: libjasper as of 1.9001 may 'crash' here if built with
+	// debugging enabled. There is an assertion in the decoding library
+	// that fails if there are not 3 channels or components (RGB). The
+	// data in icns files is usually RGBA - 4 channels. Thus, the
+	// assert will cause the program to crash.
+	if(!(image = jas_image_decode(imagestream, datafmt, 0)))
+	{
+		icns_print_err("icns_jas_jp2_to_image: Error while decoding jp2 data stream!\n");
+		return ICNS_STATUS_INVALID_DATA;
+	}
+	jas_stream_close(imagestream);
+	
+	// JP2 components, i.e. channels in icns case
+	imageChannels = jas_image_numcmpts(image);
+
+	#ifdef ICNS_DEBUG
+	printf("%d components in jp2 data\n",imageChannels);
+	#endif
+
+	// There should be 4 of these
+	if( imageChannels != 4)
+	{
+		icns_print_err("icns_jas_jp2_to_image: Number of jp2 components (%d) is invalid!\n",imageChannels);
+		return ICNS_STATUS_INVALID_DATA;
+	}
+	
+	// Assume that we can retrieve all the relevant image
+	// information from componenent number zero.
+	imageWidth = jas_image_cmptwidth(image, 0);
+	imageHeight = jas_image_cmptheight(image, 0);
+	imagePixelDepth = jas_image_cmptprec(image, 0);
+	
+	#ifdef ICNS_DEBUG
+	for(c = 0; c < 4; c++)
+	{
+		printf("component %d type: %d\n",c,jas_image_cmpttype(image, c));
+	}
+	#endif
+
+	imageDataSize = imageHeight * imageWidth * imageChannels * (imagePixelDepth / ICNS_BYTE_BITS);
+	imageOut->imageWidth = imageWidth;
+	imageOut->imageHeight = imageHeight;
+	imageOut->imageChannels = imageChannels;
+	imageOut->imagePixelDepth = imagePixelDepth;
+	imageOut->imageDataSize = imageDataSize;
+	imageData = (icns_byte_t *)malloc(imageDataSize);
+	if(!imageData) {
+		icns_print_err("icns_jas_jp2_to_image: Unable to allocate memory block of size: %d!\n",imageDataSize);
+		error = ICNS_STATUS_NO_MEMORY;
+		goto exception;
+	} else {
+		memset(imageData,0,imageDataSize);
+		imageOut->imageData = imageData;
+	}
+	
+	for(c = 0; c < 4; c++)
+	{
+		int depth = jas_image_cmptprec(image, c);
+		if(depth > 8) {
+			adjust[c] = depth - 8;
+			#ifdef ICNS_DEBUG
+			printf("BMP CONVERSION: Will be trucating component %d (%d bits) by %d bits to 8 bits.\n",c,depth,adjust[c]);
+			#endif
+		} else {
+			adjust[c] = 0;
+		}
+	}
+	
+	for (c = 0; c < 4; c++)
+	{
+		if((bufs[c] = jas_matrix_create(1, imageWidth)) == NULL)
+		{
+			icns_print_err("icns_jas_jp2_to_image: Unable to create image matix! (No memory)\n");
+			error = ICNS_STATUS_NO_MEMORY;
+			goto exception;
+		}
+	}
+	
+	for (y=0; y<imageHeight; y++)
+	{
+		icns_rgba_t *dst_pixel;
+		int r, g, b, a;
+		
+		for(c = 0; c < 4; c++)
+		{
+			if(jas_image_readcmpt(image, c, 0, y, imageWidth, 1, bufs[c]))
+			{
+				icns_print_err("icns_jas_jp2_to_image: Unable to read data for component #%d!\n",c);
+				error = ICNS_STATUS_INVALID_DATA;
+				goto exception;
+			}
+		}
+		
+		for (x=0; x<imageWidth; x++)
+		{
+			r = (jas_matrix_getv(bufs[0], x));
+			g = (jas_matrix_getv(bufs[1], x));
+			b = (jas_matrix_getv(bufs[2], x));
+			a = (jas_matrix_getv(bufs[3], x));
+			
+			dst_pixel = (icns_rgba_t *)&(imageData[y*imageWidth*imageChannels+x*imageChannels]);
+			
+			dst_pixel->r = (icns_byte_t) ((r >> adjust[0])+((r >> (adjust[0]-1))%2));
+			dst_pixel->g = (icns_byte_t) ((g >> adjust[1])+((g >> (adjust[1]-1))%2));
+			dst_pixel->b = (icns_byte_t) ((b >> adjust[2])+((b >> (adjust[2]-1))%2));
+			dst_pixel->a = (icns_byte_t) ((a >> adjust[3])+((a >> (adjust[3]-1))%2));
+			
+		}
+	}
+	
+exception:
+	
+	for(c = 0; c < 4; c++) {
+		if(bufs[c] != NULL)
+			jas_matrix_destroy(bufs[c]);
+	}
+	
+	jas_image_destroy(image);
+	jas_image_clearfmts();
+	jas_cleanup();
+	
+	return error;
+}
+
+
+int icns_jas_image_to_jp2(icns_image_t *image, icns_size_t *dataSizeOut, icns_byte_t **dataPtrOut)
+{
+	int error = ICNS_STATUS_OK;
+	jas_stream_t  *imagestream = NULL;
+	jas_image_t   *jasimage = NULL;
+	jas_matrix_t  *bufs[4] = {NULL,NULL,NULL,NULL};
+	jas_image_cmptparm_t cmptparms[4];
+	icns_sint32_t c = 0;
+	icns_sint32_t x = 0;
+	icns_sint32_t y = 0;
+	icns_sint32_t height = 0;
+	icns_sint32_t width = 0;
+	
+	if(image == NULL)
+	{
+		icns_print_err("icns_jas_image_to_jp2: Image is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	if(dataSizeOut == NULL)
+	{
+		icns_print_err("icns_jas_image_to_jp2: Data size NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	if(dataPtrOut == NULL)
+	{
+		icns_print_err("icns_jas_image_to_jp2: Data ref is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+
+	if(image->imageChannels != 4)
+	{
+		icns_print_err("icns_jas_image_to_jp2: number if channels in input image should be 4!\n");
+		return ICNS_STATUS_INVALID_DATA;
+	
+	}
+
+	if(image->imagePixelDepth != 8)
+	{
+		// Maybe support 64/128-bit images (16/32-bits per channel) in the future?
+		icns_print_err("icns_jas_image_to_jp2: jp2 images currently need to be 8 bits per pixel per channel!\n");
+		return ICNS_STATUS_INVALID_DATA;
+	
+	}
+
+	// Set these NULL for now
+	*dataSizeOut = 0;
+	*dataPtrOut = NULL;
+	
+	// Apple JP2 icns format seems to be as follows:
+	//	JP	- JP2 Signature
+	//	FTYP	- File Type
+	//	JP2	- JP2 Header
+	//		IHDR
+	//		COLR
+	//			METH = 1
+	//			EnumCS = sRGB
+	//		CDEF
+	//	JP2C	- JPEG 2000 Codestream
+	
+	// Set up the component parameters
+	for (c = 0; c < 4; c++) {
+		cmptparms[c].tlx = 0;
+		cmptparms[c].tly = 0;
+		cmptparms[c].hstep = 1;
+		cmptparms[c].vstep = 1;
+		cmptparms[c].width = image->imageWidth;
+		cmptparms[c].height = image->imageHeight;
+		cmptparms[c].prec = image->imagePixelDepth;
+		cmptparms[c].sgnd = false;
+	}
+	
+	// Initialize Jasper
+	jas_init();
+	
+	// Allocate a new japser image
+	if(!(jasimage = jas_image_create(4, cmptparms, JAS_CLRSPC_UNKNOWN)))
+	{
+		icns_print_err("icns_jas_image_to_jp2: could not allocate new jasper image! (Likely out of memory)\n");
+		return ICNS_STATUS_NO_MEMORY;
+	}
+	
+	// Set up the image components
+	jas_image_setclrspc(jasimage, JAS_CLRSPC_SRGB);
+	jas_image_setcmpttype(jasimage, 0, JAS_IMAGE_CT_RGB_R);
+	jas_image_setcmpttype(jasimage, 1, JAS_IMAGE_CT_RGB_G);
+	jas_image_setcmpttype(jasimage, 2, JAS_IMAGE_CT_RGB_B);
+	jas_image_setcmpttype(jasimage, 3, JAS_IMAGE_CT_OPACITY);
+
+	width = image->imageWidth;
+	height = image->imageHeight;
+	
+	// Allocate the matrix buffers
+	for(c = 0; c < 4; c++)
+	{
+		if((bufs[c] = jas_matrix_create(height, width)) == NULL)
+		{
+			icns_print_err("icns_jas_image_to_jp2: Unable to create image matix! (No memory)\n");
+			error = ICNS_STATUS_NO_MEMORY;
+			goto exception;
+		}
+	}
+		
+	// Copy all the image data into the jasper matrices
+	for (y=0; y<height; y++)
+	{
+		icns_rgba_t *src_pixel;
+		int		offset = 0;
+		
+		for (x=0; x<width; x++)
+		{
+			offset = y*width*4+x*4;
+			src_pixel = (icns_rgba_t *)&((image->imageData)[offset]);
+
+			jas_matrix_set(bufs[0], y, x, src_pixel->r);
+			jas_matrix_set(bufs[1], y, x, src_pixel->g);
+			jas_matrix_set(bufs[2], y, x, src_pixel->b);
+			jas_matrix_set(bufs[3], y, x, src_pixel->a);
+		}
+	}
+
+	// Write each channel component to the jasper image
+	for(c = 0; c < 4; c++)
+	{
+		if(jas_image_writecmpt(jasimage, c, 0, 0, width, height, bufs[c]))
+		{
+			icns_print_err("icns_jas_image_to_jp2: Unable to write data for component #%d!\n",c);
+			error = ICNS_STATUS_INVALID_DATA;
+			goto exception;
+		}
+	}
+
+	// Create a new in-memory stream - Jasper will allocate and grow this as needed
+	imagestream = jas_stream_memopen( NULL, 0);
+	
+	if(jas_image_encode(jasimage, imagestream, jas_image_strtofmt("jp2"),NULL)) {
+		icns_print_err("icns_jas_image_to_jp2: Unable to encode jp2 data!\n");
+		error = ICNS_STATUS_INVALID_DATA;
+		goto exception;
+	}
+	
+	jas_stream_flush(imagestream);
+
+	// Get the size of the stream - add 34 bytes for cdef
+	*dataSizeOut = jas_stream_length(imagestream)+34;
+
+	#ifdef ICNS_DEBUG
+	printf("Compressed jp2 data size is %d\n",*dataSizeOut);
+	#endif
+
+	// Offload the stream to our memory buffers
+	*dataPtrOut = (icns_byte_t *)malloc(*dataSizeOut);
+	if(!(*dataPtrOut))
+	{
+		icns_print_err("icns_jas_image_to_jp2: Unable to allocate memory block of size: %d ($s:%m)!\n",(int)*dataSizeOut);
+		return ICNS_STATUS_NO_MEMORY;
+	}
+	
+	jas_stream_rewind(imagestream);
+	jas_stream_read(imagestream,*dataPtrOut,*dataSizeOut);
+
+	jas_stream_close(imagestream);
+	
+	icns_place_jp2_cdef(*dataPtrOut,*dataSizeOut);
+
+exception:
+	
+	for(c = 0; c < 4; c++) {
+		if(bufs[c] != NULL)
+			jas_matrix_destroy(bufs[c]);
+	}
+	
+	jas_image_destroy(jasimage);
+	jas_image_clearfmts();
+	jas_cleanup();
+		
+	return error;
+}
+
+#endif /* ifdef ICNS_JASPER */
+
+
+
+// Only compile the openjpeg routines if we have support for it
+#ifdef ICNS_OPENJPEG
+
+int icns_opj_jp2_to_image(icns_size_t dataSize, icns_byte_t *dataPtr, icns_image_t *imageOut)
+{
+	int         error = ICNS_STATUS_OK;
+	opj_image_t *image = NULL;
+
+	if(dataPtr == NULL)
+	{
+		icns_print_err("icns_opj_jp2_to_image: JP2 data is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	if(imageOut == NULL)
+	{
+		icns_print_err("icns_opj_jp2_to_image: Image out is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	if(dataSize == 0)
+	{
+		icns_print_err("icns_opj_jp2_to_image: Invalid data size! (%d)\n",dataSize);
+		return ICNS_STATUS_INVALID_DATA;
+	}
+
+	error = icns_opj_jp2_dec(dataSize, dataPtr, &image);
+	
+	if(!image)
+		return ICNS_STATUS_INVALID_DATA;
+
+	error = icns_opj_to_image(image,imageOut);
+
+	opj_image_destroy(image);
+
+	return error;	
+}
+
+// Decode jp2 data using OpenJPEG
+int icns_opj_jp2_dec(icns_size_t dataSize, icns_byte_t *dataPtr, opj_image_t **imageOut)
+{
+	opj_event_mgr_t    event_mgr;	
+	opj_dparameters_t  parameters;
+	opj_dinfo_t        *dinfo = NULL;
+	opj_cio_t          *cio = NULL;
+	opj_image_t        *image = NULL;
+
+	memset(&event_mgr, 0, sizeof(opj_event_mgr_t));
+	event_mgr.error_handler = icns_opj_error_callback;
+	event_mgr.warning_handler = icns_opj_warning_callback;
+	event_mgr.info_handler = icns_opj_info_callback;
+
+	opj_set_default_decoder_parameters(&parameters);
+
+	dinfo = opj_create_decompress(CODEC_JP2);
+	opj_set_event_mgr((opj_common_ptr)dinfo, &event_mgr, stderr);
+	opj_setup_decoder(dinfo, &parameters);
+
+	cio = opj_cio_open((opj_common_ptr)dinfo, dataPtr, dataSize);
+
+	image = opj_decode(dinfo, cio);
+	if(!image) {
+		icns_print_err("icns_opj_jp2_dec: failed to decode image!\n");
+		opj_destroy_decompress(dinfo);
+		opj_cio_close(cio);
+		return ICNS_STATUS_INVALID_DATA;
+	} else {
+		*imageOut = image;	
+	}
+
+	opj_cio_close(cio);
+	opj_destroy_decompress(dinfo);
+
+	return ICNS_STATUS_OK;
+}
+
+// Convert from opj_image_t to icns_image_t
+int icns_opj_to_image(opj_image_t *opjImg, icns_image_t *iconImg)
+{
+	int		error = ICNS_STATUS_OK;
+	icns_sint8_t    adjust[4] = {0,0,0,0};
+	icns_byte_t	*dataPtr = NULL;
+	int             c = 0;
+	int             i, j;
+	int             rowOffset, colOffset;
+	
+	if(opjImg == NULL)
+	{
+		icns_print_err("icns_opj_to_image: OpenJPEG image is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	if(iconImg == NULL)
+	{
+		icns_print_err("icns_opj_to_image: Icon image is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	iconImg->imageWidth = opjImg->comps[0].w;
+	iconImg->imageHeight = opjImg->comps[0].h;
+	iconImg->imageChannels = opjImg->numcomps;
+	iconImg->imagePixelDepth = opjImg->comps[0].prec;
+	
+	iconImg->imageDataSize = iconImg->imageHeight * iconImg->imageWidth * iconImg->imagePixelDepth; // * iconChannels ?
+	iconImg->imageData = (icns_byte_t *)malloc(iconImg->imageDataSize);
+	if(!iconImg->imageData) {
+		icns_print_err("icns_create_family: Unable to allocate memory block of size: %d!\n",iconImg->imageDataSize);
+		return ICNS_STATUS_NO_MEMORY;
+	}
+	memset(iconImg->imageData,0,iconImg->imageDataSize);
+	
+	dataPtr = iconImg->imageData;
+	
+	for(c = 0; c < 4; c++)
+	{
+		int depth = opjImg->comps[c].prec;
+		if(depth > 8) {
+			adjust[c] = depth - 8;
+			#ifdef ICNS_DEBUG
+			printf("BMP CONVERSION: Will be trucating component %d (%d bits) by %d bits to 8 bits.\n",c,depth,adjust[c]);
+			#endif
+		} else {
+			adjust[c] = 0;
+		}
+	}
+	
+	for (i = 0; i < iconImg->imageHeight; i++) {
+		rowOffset = i * iconImg->imageChannels * iconImg->imageWidth;
+		for(j = 0; j < iconImg->imageWidth; j++) {
+			icns_rgba_t *dst_pixel;
+			int r, g, b, a;
+			
+			colOffset = j * iconImg->imageChannels;
+						
+			r = opjImg->comps[0].data[i*iconImg->imageWidth+j];
+			r += (opjImg->comps[0].sgnd ? 1 << (opjImg->comps[0].prec - 1) : 0);
+			g = opjImg->comps[1].data[i*iconImg->imageWidth+j];
+			g += (opjImg->comps[1].sgnd ? 1 << (opjImg->comps[1].prec - 1) : 0);
+			b = opjImg->comps[2].data[i*iconImg->imageWidth+j];
+			b += (opjImg->comps[2].sgnd ? 1 << (opjImg->comps[2].prec - 1) : 0);
+			a = opjImg->comps[3].data[i*iconImg->imageWidth+j];
+			a += (opjImg->comps[3].sgnd ? 1 << (opjImg->comps[3].prec - 1) : 0);
+			
+			dst_pixel = (icns_rgba_t *)&(dataPtr[rowOffset + colOffset]);
+			
+			dst_pixel->r = (icns_byte_t) ((r >> adjust[0])+((r >> (adjust[0]-1))%2));
+			dst_pixel->g = (icns_byte_t) ((g >> adjust[1])+((g >> (adjust[1]-1))%2));
+			dst_pixel->b = (icns_byte_t) ((b >> adjust[2])+((b >> (adjust[2]-1))%2));
+			dst_pixel->a = (icns_byte_t) ((a >> adjust[3])+((a >> (adjust[3]-1))%2));
+		}
+	}
+	
+	return error;
+}
+
+int icns_opj_image_to_jp2(icns_image_t *iconImg, icns_size_t *dataSizeOut, icns_byte_t **dataPtrOut)
+{
+	int		     error = ICNS_STATUS_OK;
+	opj_event_mgr_t      event_mgr;
+	opj_cparameters_t    parameters;
+	OPJ_COLOR_SPACE      color_space = CLRSPC_SRGB;
+	opj_image_cmptparm_t cmptparm[4];
+	opj_image_t	     *opjImg = NULL;
+	icns_byte_t	     *dataPtr = NULL;
+	int                  i, j;
+	int                  rowOffset, colOffset;
+	opj_cinfo_t          *cinfo = NULL;
+	opj_cio_t            *cio = NULL;
+	int                  success = 0;
+	
+	if(iconImg == NULL)
+	{
+		icns_print_err("icns_opj_image_to_jp2: Image is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	if(dataSizeOut == NULL)
+	{
+		icns_print_err("icns_opj_image_to_jp2: Data size NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	if(dataPtrOut == NULL)
+	{
+		icns_print_err("icns_opj_image_to_jp2: Data ref is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+
+	if(iconImg->imageChannels != 4)
+	{
+		icns_print_err("icns_image_to_opj: number if channels in input image should be 4!\n");
+		return ICNS_STATUS_INVALID_DATA;
+	
+	}
+
+	if(iconImg->imagePixelDepth != 8)
+	{
+		// Maybe support 64/128-bit images (16/32-bits per channel) in the future?
+		icns_print_err("icns_image_to_opj: jp2 images currently need to be 8 bits per pixel per channel!\n");
+		return ICNS_STATUS_INVALID_DATA;
+	}
+	
+	*dataSizeOut = 0;
+	*dataPtrOut = NULL;
+	
+	memset(&event_mgr, 0, sizeof(opj_event_mgr_t));
+	event_mgr.error_handler = icns_opj_error_callback;
+	event_mgr.warning_handler = icns_opj_warning_callback;
+	event_mgr.info_handler = icns_opj_info_callback;
+	
+	opj_set_default_encoder_parameters(&parameters);
+
+	parameters.tcp_numlayers = 1;
+	parameters.tcp_rates[0] = 1;
+	parameters.cp_disto_alloc = 1;
+	parameters.irreversible = 0;
+	
+	memset(&cmptparm[0], 0, 4 * sizeof(opj_image_cmptparm_t));
+	for(i = 0; i < 4; i++) {
+		
+		cmptparm[i].w = iconImg->imageWidth;
+		cmptparm[i].h = iconImg->imageHeight;
+		cmptparm[i].dx = 1;
+		cmptparm[i].dy = 1;
+		cmptparm[i].prec = iconImg->imagePixelDepth;
+		cmptparm[i].bpp = iconImg->imagePixelDepth;
+		cmptparm[i].sgnd = 0;
+	}
+	
+	opjImg = opj_image_create(4, &cmptparm[0], color_space);
+	if(!opjImg) {
+		icns_print_err("icns_image_to_opj: Unable to create new image!\n");
+		return ICNS_STATUS_INVALID_DATA;
+	}
+	
+	opjImg->x0 = 0;
+	opjImg->y0 = 0;
+	opjImg->x1 = iconImg->imageWidth;
+	opjImg->y1 = iconImg->imageHeight; 
+	
+	dataPtr = iconImg->imageData;
+	for (i = 0; i < iconImg->imageHeight; i++) {
+		rowOffset = i * iconImg->imageChannels * iconImg->imageWidth;
+		for(j = 0; j < iconImg->imageWidth; j++) {
+			icns_rgba_t *src_pixel;
+			int p = i * iconImg->imageWidth + j;
+			
+			colOffset = j * iconImg->imageChannels;
+			
+			src_pixel = (icns_rgba_t *)&(dataPtr[rowOffset + colOffset]);
+			
+			opjImg->comps[0].data[p] = src_pixel->r;
+			opjImg->comps[1].data[p] = src_pixel->g;
+			opjImg->comps[2].data[p] = src_pixel->b;
+			opjImg->comps[3].data[p] = src_pixel->a;
+		}
+	}
+	
+	cinfo = opj_create_compress(CODEC_JP2);
+	opj_set_event_mgr((opj_common_ptr)cinfo, &event_mgr, stderr);
+	opj_setup_encoder(cinfo, &parameters, opjImg);
+
+	cio = opj_cio_open((opj_common_ptr)cinfo, NULL, 0);
+
+	success = opj_encode(cinfo, cio, opjImg, NULL);
+	if (!success) {
+		opj_cio_close(cio);
+		icns_print_err("icns_opj_jp2_enc: Error while encoding jp2 data!\n");
+		error = ICNS_STATUS_INVALID_DATA;
+		goto exception;
+	}
+	
+	*dataSizeOut = cio_tell(cio) + 34;
+	*dataPtrOut = (icns_byte_t *)malloc(*dataSizeOut);
+
+	if(!(*dataPtrOut))
+	{
+		icns_print_err("icns_jas_image_to_jp2: Unable to allocate memory block of size: %d!\n",(int)*dataSizeOut);
+		error = ICNS_STATUS_NO_MEMORY;
+		goto exception;
+	}
+	
+	memcpy(*dataPtrOut,cio->buffer,*dataSizeOut - 34);
+	
+	icns_place_jp2_cdef(*dataPtrOut,*dataSizeOut);
+	
+exception:
+	if(opjImg) {
+		opj_image_destroy(opjImg);
+		opjImg = NULL;
+	}
+	if(cio) {
+		opj_cio_close(cio);
+		cio = NULL;
+	}
+	if(cinfo) {
+		opj_destroy_compress(cinfo);
+		cinfo = NULL;
+	}
+	
+	return error;
+}
+
+void icns_opj_error_callback(const char *msg, void *client_data) {
+}
+
+void icns_opj_warning_callback(const char *msg, void *client_data) {
+}
+
+void icns_opj_info_callback(const char *msg, void *client_data) {
+}
+
+#endif /* ifdef ICNS_OPENJPEG */
+
+
+// Add cdef block - requires that dataPtr has 34 extra bytes!
+void icns_place_jp2_cdef(icns_byte_t *dataPtr, icns_size_t dataSize)
+{
+	icns_sint32_t	offset = 0;
+	icns_uint32_t	blocksize = 0;
+	icns_uint32_t	blocktype = 0;
+	icns_byte_t	*bytes = NULL;
+	icns_uint32_t	headeroffs = 0;
+	icns_uint32_t	headersize = 0;
+	icns_byte_t	cdef[34];
+	
+	// Initialize CDEF block
+	
+	// big endian block size - 34 bytes
+	cdef[0] = 0x00;
+	cdef[1] = 0x00;
+	cdef[2] = 0x00;
+	cdef[3] = 0x22;
+	
+	// id = 'cdef'
+	cdef[4] = 'c';
+	cdef[5] = 'd';
+	cdef[6] = 'e';
+	cdef[7] = 'f';
+	
+	// component count - 4
+	cdef[8] = 0x00;
+	cdef[9] = 0x04;
+	
+	// component number: 0
+	cdef[10] = 0x00;
+	cdef[11] = 0x00;
+	// component type: 0=color component
+	cdef[12] = 0x00;
+	cdef[13] = 0x00;
+	// component association: 1=color 1 assoc
+	cdef[14] = 0x00;
+	cdef[15] = 0x01;
+	
+	// component number: 3
+	cdef[16] = 0x00;
+	cdef[17] = 0x03;
+	// component type: 1=opacity component
+	cdef[18] = 0x00;
+	cdef[19] = 0x01;
+	// component association: 0=whole image assoc
+	cdef[20] = 0x00;
+	cdef[21] = 0x00;
+	
+	// component number: 1
+	cdef[22] = 0x00;
+	cdef[23] = 0x01;
+	// component type: 0=color component
+	cdef[24] = 0x00;
+	cdef[25] = 0x00;
+	// component association: 2=color 2 assoc
+	cdef[26] = 0x00;
+	cdef[27] = 0x02;
+	
+	// component number: 2
+	cdef[28] = 0x00;
+	cdef[29] = 0x02;
+	// component type: 0=color component
+	cdef[30] = 0x00;
+	cdef[31] = 0x00;
+	// component association: 3=color 3 assoc
+	cdef[32] = 0x00;
+	cdef[33] = 0x03;
+	
+	// skip 12 bytes to pass signature block
+	offset = 12;
+	bytes = dataPtr + offset;
+	
+	// look for jp2h block (0x6A73268)
+	do
+	{
+		blocksize = bytes[3]|bytes[2]<<8|bytes[1]<<16|bytes[0]<<24;
+		offset += 4;
+		bytes = dataPtr + offset;
+		blocktype = bytes[3]|bytes[2]<<8|bytes[1]<<16|bytes[0]<<24;
+		if(blocktype == 0x6A703268) {
+			offset += 4;
+			bytes = dataPtr + offset;
+		} else {
+			offset = offset + (blocksize - 4);
+			bytes = dataPtr + offset;
+		}
+	} while(blocktype != 0x6A703268 && offset < dataSize);
+	
+	// make sure we found the jp2h block
+	if(blocktype == 0x6A703268)
+	{
+		uint32_t c = 0;
+		
+		// keep track of the current header offset and size
+		headeroffs = offset;
+		headersize = blocksize-8;
+		
+		// update the header block size
+		bytes = dataPtr + (headeroffs-8);
+		blocksize += 34;
+		bytes[0] = blocksize >> 24;
+		bytes[1] = blocksize >> 16;
+		bytes[2] = blocksize >> 8;
+		bytes[3] = blocksize;
+		
+		// look for colr block (0x636F6C72)
+		offset = headeroffs;
+		bytes = dataPtr + offset;
+		do
+		{
+			blocksize = bytes[3]|bytes[2]<<8|bytes[1]<<16|bytes[0]<<24;
+			offset += 4;
+			bytes = dataPtr + offset;
+			blocktype = bytes[3]|bytes[2]<<8|bytes[1]<<16|bytes[0]<<24;
+			offset = offset + (blocksize - 4);
+			bytes = dataPtr + offset;
+		} while(blocktype != 0x636F6C72 && offset < headeroffs+headersize);
+		
+		// if we have colr block, place cdef after it
+		// otherwise, place cdef block at start of ihdr
+		if(blocktype != 0x636F6C72) {
+			offset = headeroffs;
+		}
+	
+		// shuffle the bytes backwards to make room for the cdef
+		bytes = dataPtr;
+		for(c = (dataSize)-35; c >= offset; c--) {
+			bytes[c+34] = bytes[c];
+		}
+		
+		// copy in the cdef block
+		for(c = 0; c < 34; c++) {
+			bytes[c+offset] = cdef[c];
+		}
+	}
+}

src/add-ons/translators/icns/libicns/icns_png.c

@@ -0,0 +1,201 @@
+/*
+File:       icns_png.c
+Copyright (C) 2001-2012 Mathew Eis <[email protected]>
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, 
+Boston, MA 02110-1301, USA.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "icns.h"
+#include "icns_internals.h"
+
+#include <png.h>
+
+typedef struct icns_png_io_ref {
+	void*	data;
+	size_t	size;
+	size_t	offset;
+} icns_png_io_ref;
+
+static void icns_png_read_memory(png_structp png_ptr, png_bytep data, png_size_t length) {
+	icns_png_io_ref* _ref = (icns_png_io_ref*) png_get_io_ptr( png_ptr );
+	memcpy( data, (char*)_ref->data + _ref->offset, length );
+	_ref->offset += length;
+}
+
+int icns_png_to_image(icns_size_t dataSize, icns_byte_t *dataPtr, icns_image_t *imageOut)
+{
+	int error = ICNS_STATUS_OK;
+	icns_png_io_ref io_data	= { dataPtr, dataSize, 0 };	
+	png_structp png_ptr = NULL;
+	png_infop info_ptr = NULL;
+        png_uint_32 w;
+        png_uint_32 h;
+        png_bytep *rows;
+        int bit_depth;
+        int32_t color_type;
+        int row;
+        int rowsize;        
+	
+	
+	if(dataPtr == NULL)
+	{
+		icns_print_err("icns_png_to_image: JP2 data is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	if(imageOut == NULL)
+	{
+		icns_print_err("icns_png_to_image: Image out is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	if(dataSize == 0)
+	{
+		icns_print_err("icns_png_to_image: Invalid data size! (%d)\n",dataSize);
+		return ICNS_STATUS_INVALID_DATA;
+	}
+	
+	#ifdef ICNS_DEBUG
+	printf("Decoding PNG image...\n");
+	#endif
+
+	png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+
+	if(png_ptr == NULL) {
+		return ICNS_STATUS_NO_MEMORY;
+	}
+
+	info_ptr = png_create_info_struct(png_ptr);
+
+	if(info_ptr == NULL) {
+	   png_destroy_read_struct(&png_ptr, NULL, NULL);
+	   return ICNS_STATUS_NO_MEMORY;
+	}
+
+	if (setjmp(png_jmpbuf(png_ptr)))
+        {
+                png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+                return ICNS_STATUS_INVALID_DATA;
+        }
+
+	// set libpng to read from memory
+	png_set_read_fn(png_ptr, (void *)&io_data, &icns_png_read_memory); 
+	
+        png_read_info(png_ptr, info_ptr);
+        png_get_IHDR(png_ptr, info_ptr, &w, &h, &bit_depth, &color_type, NULL, NULL, NULL);
+
+        switch (color_type)
+        {
+                case PNG_COLOR_TYPE_RGB:
+                        if (bit_depth == 16) {
+                                png_set_strip_16(png_ptr);
+                                bit_depth = 8;
+                        }
+
+                        png_set_add_alpha(png_ptr, 0xff, PNG_FILLER_AFTER);
+                        break;
+
+                case PNG_COLOR_TYPE_RGB_ALPHA:
+                        if (bit_depth == 16) {
+                                png_set_strip_16(png_ptr);
+                                bit_depth = 8;
+                        }
+
+                        break;
+	}
+	
+        png_read_update_info(png_ptr, info_ptr);
+	
+        rowsize = png_get_rowbytes(png_ptr, info_ptr);
+        rows = malloc (sizeof(png_bytep) * h);
+
+	imageOut->imageWidth = w;
+        imageOut->imageHeight = h;
+        imageOut->imageChannels = 4;
+        imageOut->imagePixelDepth = 8;
+        imageOut->imageDataSize = w * h * 4;
+        imageOut->imageData = malloc( rowsize * h + 8 );
+
+	if(imageOut->imageData == NULL) {
+		png_destroy_read_struct(&png_ptr, NULL, NULL);
+	        free(rows);
+		return ICNS_STATUS_NO_MEMORY;
+	}
+	
+        rows[0] = imageOut->imageData;
+        for (row = 1; row < h; row++) {
+                rows[row] = rows[row-1] + rowsize;
+        }
+
+        png_read_image(png_ptr, rows);
+        png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+
+        free(rows);
+
+	#ifdef ICNS_DEBUG
+	if(error == ICNS_STATUS_OK) {
+		printf("  decode result:\n");
+		printf("  width is: %d\n",imageOut->imageWidth);
+		printf("  height is: %d\n",imageOut->imageHeight);
+		printf("  channels are: %d\n",imageOut->imageChannels);
+		printf("  pixel depth is: %d\n",imageOut->imagePixelDepth);
+		printf("  data size is: %d\n",(int)imageOut->imageDataSize);
+	} else {
+		printf("  decode failed.\n");
+	}
+	#endif
+	
+	return error;
+}
+
+
+int icns_image_to_png(icns_image_t *image, icns_size_t *dataSizeOut, icns_byte_t **dataPtrOut)
+{
+	int error = ICNS_STATUS_OK;
+	
+	if(image == NULL)
+	{
+		icns_print_err("icns_image_to_png: Image is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	if(dataSizeOut == NULL)
+	{
+		icns_print_err("icns_image_to_png: Data size NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	if(dataPtrOut == NULL)
+	{
+		icns_print_err("icns_image_to_png: Data ref is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	#ifdef ICNS_DEBUG
+	printf("Encoding PNG image...\n");
+	#endif
+	
+	// TODO:
+	// Verify that size is > 256x256 and 32-bit
+	// Then convert an icns_image to PNG data
+	return error;
+}
+

src/add-ons/translators/icns/libicns/icns_rle24.c

@@ -0,0 +1,411 @@
+/*
+File:       icns_rle24.c
+Copyright (C) 2001-2012 Mathew Eis <[email protected]>
+              2007 Thomas Lübking <[email protected]>
+              2002 Chenxiao Zhao <[email protected]>
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, 
+Boston, MA 02110-1301, USA.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "icns.h"
+#include "icns_internals.h"
+//***************************** icns_decode_rle24_data ****************************//
+// Decode a rgb 24 bit rle encoded data stream into 32 bit argb (alpha is ignored)
+
+int icns_decode_rle24_data(icns_size_t rawDataSize, icns_byte_t *rawDataPtr,icns_size_t expectedPixelCount, icns_size_t *dataSizeOut, icns_byte_t **dataPtrOut)
+{
+	icns_uint8_t	colorOffset = 0;
+	icns_byte_t	colorValue = 0;
+	icns_uint8_t	runLength = 0;
+	icns_uint32_t	dataOffset = 0;
+	icns_uint32_t	pixelOffset = 0;
+	icns_uint32_t	i = 0;
+	icns_byte_t	*destIconData = NULL;	// Decompressed Raw Icon Data
+	icns_uint32_t	destIconDataSize = 0;
+	
+	if(rawDataPtr == NULL)
+	{
+		icns_print_err("icns_decode_rle24_data: rle decoder data in ptr is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	if(dataSizeOut == NULL)
+	{
+		icns_print_err("icns_decode_rle24_data: rle decoder data out size ref is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	if(dataPtrOut == NULL)
+	{
+		icns_print_err("icns_decode_rle24_data: rle decoder data out ptr is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	// Calculate required data storage (pixels * 4 channels)
+	destIconDataSize = expectedPixelCount * 4;
+	
+	#ifdef ICNS_DEBUG
+		printf("Compressed RLE data size is %d\n",(int)rawDataSize);
+		printf("Decompressed will be %d bytes (%d pixels)\n",(int)destIconDataSize,(int)expectedPixelCount);
+	#endif
+	
+	if( (*dataSizeOut != destIconDataSize) || (*dataPtrOut == NULL) )
+	{
+		if(*dataPtrOut != NULL)
+			free(*dataPtrOut);
+		
+		// Allocate the block for the decoded memory and set to 0
+		destIconData = (icns_byte_t *)malloc(destIconDataSize);
+		if(!destIconData)
+		{
+			icns_print_err("icns_decode_rle24_data: Unable to allocate memory block of size: %d ($s:%m)!\n",(int)destIconDataSize);
+			return ICNS_STATUS_NO_MEMORY;
+		}
+		memset(destIconData,0,destIconDataSize);
+	}
+	else
+	{
+		destIconData = *dataPtrOut;
+	}
+	
+	#ifdef ICNS_DEBUG
+		printf("Decoding RLE data into RGB pixels...\n");
+	#endif
+
+	// What's this??? In the 128x128 icons, we need to start 4 bytes
+	// ahead. There is often a NULL padding here for some reason. If
+	// we don't, the red channel will be off by 2 pixels, or worse
+	if( *((icns_uint32_t*)rawDataPtr) == 0x00000000 )
+	{
+		#ifdef ICNS_DEBUG
+		printf("4 byte null padding found in rle data!\n");
+		#endif
+		dataOffset = 4;
+	}
+	else
+	{
+		dataOffset = 0;
+	}
+	
+	// Data is stored in red run, green run,blue run
+	// So we decompress to pixel format RGBA
+	// RED:   byte[0], byte[4], byte[8]  ...
+	// GREEN: byte[1], byte[5], byte[9]  ...
+	// BLUE:  byte[2], byte[6], byte[10] ...
+	// ALPHA: byte[3], byte[7], byte[11] do nothing with these bytes
+	for(colorOffset = 0; colorOffset < 3; colorOffset++)
+	{
+		pixelOffset = 0;
+		while((pixelOffset < expectedPixelCount) && (dataOffset < rawDataSize))
+		{
+			if( (rawDataPtr[dataOffset] & 0x80) == 0)
+			{
+				// Top bit is clear - run of various values to follow
+				runLength = (0xFF & rawDataPtr[dataOffset++]) + 1; // 1 <= len <= 128
+				for(i = 0; (i < runLength) && (pixelOffset < expectedPixelCount) && (dataOffset < rawDataSize); i++) {
+					destIconData[(pixelOffset * 4) + colorOffset] = rawDataPtr[dataOffset++];
+					pixelOffset++;
+				}
+			}
+			else
+			{
+				// Top bit is set - run of one value to follow
+				runLength = (0xFF & rawDataPtr[dataOffset++]) - 125; // 3 <= len <= 130
+				// Set the value to the color shifted to the correct bit offset
+				colorValue = rawDataPtr[dataOffset++];
+				
+				for(i = 0; (i < runLength) && (pixelOffset < expectedPixelCount); i++) {
+					destIconData[(pixelOffset * 4) + colorOffset] = colorValue;
+					pixelOffset++;
+				}
+			}
+		}
+	}
+	
+	*dataSizeOut = destIconDataSize;
+	*dataPtrOut = destIconData;
+	
+	return ICNS_STATUS_OK;
+}
+
+//***************************** icns_encode_rle24_data *******************************************//
+// Encode an 32 bit argb data stream into a 24 bit rgb rle encoded data stream (alpha is ignored)
+
+int icns_encode_rle24_data(icns_size_t dataSizeIn, icns_byte_t *dataPtrIn,icns_size_t *dataSizeOut, icns_byte_t **dataPtrOut)
+{
+	unsigned long	dataInCount = 0;
+	unsigned long 	dataInChanSize = 0;
+	icns_byte_t	*rgbaDataPtr = NULL;
+	icns_sint8_t	*dataTemp = NULL;
+	unsigned long	dataTempCount = 0;
+	icns_uint8_t	colorOffset = 0;
+	icns_uint8_t	dataByte = 0;
+	icns_uint8_t	*dataRun = NULL;
+	icns_bool_t	runType = 0;
+	icns_uint8_t	runLength = 0; // Runs will never go over 130, one byte is ok
+	int		runCount = 0;
+	
+	if(dataPtrIn == NULL)
+	{
+		icns_print_err("icns_encode_rle24_data: rle encoder data in ptr is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	if(dataSizeOut == NULL)
+	{
+		icns_print_err("icns_encode_rle24_data: rle encoder data out size ref is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+	
+	if(dataPtrOut == NULL)
+	{
+		icns_print_err("icns_encode_rle24_data: rle encoder data out ptr ref is NULL!\n");
+		return ICNS_STATUS_NULL_PARAM;
+	}
+
+	// Assumptions of what icns rle data is all about:
+	// A) Each channel is encoded indepenent of the next.
+	// B) An encoded channel looks like this:
+	//    0xRL 0xCV 0xCV 0xRL 0xCV - RL is run-length and CV is color value.
+	// C) There are two types of runs
+	//    1) Run of same value - high bit of RL is set
+	//    2) Run of differing values - high bit of RL is NOT set
+	// D) 0xRL also has two ranges
+	//    1) for set high bit RL, 3 to 130
+	//    2) for clr high bit RL, 1 to 128
+	// E) 0xRL byte is therefore set as follows:
+	//    1) for same values, RL = RL - 1
+	//    2) different values, RL = RL + 125
+	//    3) both methods will automatically set the high bit appropriately
+	// F) 0xCV byte are set accordingly
+	//    1) for differing values, run of all differing values
+	//    2) for same values, only one byte of that values
+	// Estimations put the absolute worst case scenario as the
+	// final compressed data being slightly LARGER. So we need to be
+	// careful about allocating memory. (Did I miss something?)
+	// tests seem to indicate it will never be larger than the original
+	
+	// This block is for the new RLE encoded data - make it 25% larger
+	dataTemp = (icns_sint8_t *)malloc(dataSizeIn + (dataSizeIn / 4));
+	if(dataTemp == NULL)
+	{
+		icns_print_err("icns_encode_rle24_data: Unable to allocate memory block of size: %d!\n",(int)dataSizeIn);
+		return ICNS_STATUS_NO_MEMORY;
+	}
+	memset(dataTemp,0,dataSizeIn);
+	
+	// This block is for a run of RLE encoded data
+	dataRun = (icns_uint8_t *)malloc(140);
+	if(dataRun == NULL)
+	{
+		icns_print_err("icns_encode_rle24_data: Unable to allocate memory block of size: %d!\n",140);
+		free(dataTemp);
+		return ICNS_STATUS_NO_MEMORY;
+	}
+	memset(dataRun,0,140);
+	
+	// Set the data ptr
+	rgbaDataPtr = (icns_byte_t *)dataPtrIn;
+	
+	// There's always going to be 4 channels in this
+	// so we want our counter to increment through
+	// channels, not bytes....
+	dataInChanSize = dataSizeIn / 4;
+	
+	// Move forward 4 bytes for 128 size - who knows why this should be
+	if(dataSizeIn >= 65536)
+		dataTempCount = 4;
+	
+	// Data is stored in red run, green run,blue run
+	// So we compress from pixel format RGBA
+	// RED:   byte[0], byte[4], byte[8]  ...
+	// GREEN: byte[1], byte[5], byte[9]  ...
+	// BLUE:  byte[2], byte[6], byte[10] ...
+	// ALPHA: byte[3], byte[7], byte[11] do nothing with these bytes
+	for(colorOffset = 0; colorOffset < 3; colorOffset++)
+	{
+		runCount = 0;
+		
+		// Set the first byte of the run...
+		dataRun[0] = *(rgbaDataPtr+colorOffset);
+		
+		// Start with a runlength of 1 for the first byte
+		runLength = 1;
+		
+		// Assume that the run will be different for now... We can change this later
+		runType = 0; // 0 for low bit (different), 1 for high bit (same)	
+		
+		// Start one byte ahead
+		for(dataInCount = 1; dataInCount < dataInChanSize; dataInCount++)
+		{
+			dataByte = *(rgbaDataPtr+colorOffset+(dataInCount*4));
+			
+			if(runLength < 2)
+			{
+				// Simply append to the current run
+				dataRun[runLength++] = dataByte;
+			}
+			else if(runLength == 2)
+			{
+				// Decide here if the run should be same values or different values
+				
+				// If the last three values were the same, we can change to a same-type run
+				if( (dataByte == dataRun[runLength-1]) && (dataByte == dataRun[runLength-2]) )
+					runType = 1;
+				else
+					runType = 0;
+				
+				dataRun[runLength++] = dataByte;
+			}
+			else // Greater than or equal to 2
+			{
+				if(runType == 0 && runLength < 128) // Different type run
+				{
+					// If the new value matches both of the last two values, we have a new
+					// same-type run starting with the previous two bytes
+					if( (dataByte == dataRun[runLength-1]) && (dataByte == dataRun[runLength-2]) )
+					{
+						// Set the RL byte
+						*(dataTemp+dataTempCount) = runLength - 3;
+						dataTempCount++;
+						
+						// Copy 0 to runLength-2 bytes to the RLE data here
+						memcpy( dataTemp+dataTempCount , dataRun , runLength - 2 );
+						dataTempCount = dataTempCount + (runLength - 2);
+						runCount++;
+						
+						// Set up the new same-type run
+						dataRun[0] = dataRun[runLength-2];
+						dataRun[1] = dataRun[runLength-1];
+						dataRun[2] = dataByte;
+						runLength = 3;
+						runType = 1;
+					}
+					else // They don't match, so we can proceed
+					{
+						dataRun[runLength++] = dataByte;
+					}
+				}
+				else if(runType == 1 && runLength < 130) // Same type run
+				{
+					// If the new value matches both of the last two values, we
+					// can safely continue
+					if( (dataByte == dataRun[runLength-1]) && (dataByte == dataRun[runLength-2]) )
+					{
+						dataRun[runLength++] = dataByte;
+					}
+					else // They don't match, so we need to start a new run
+					{
+						// Set the RL byte
+						*(dataTemp+dataTempCount) = runLength + 125;
+						dataTempCount++;
+						
+						// Only copy the first byte, since all the remaining values are identical
+						*(dataTemp+dataTempCount) = dataRun[0];
+						dataTempCount++;
+						runCount++;
+						
+						// Copy 0 to runLength bytes to the RLE data here
+						dataRun[0] = dataByte;
+						runLength = 1;
+						runType = 0;
+					}
+				}
+				else // Exceeded run limit, need to start a new one
+				{
+					if(runType == 0)
+					{
+						// Set the RL byte low
+						*(dataTemp+dataTempCount) = runLength - 1;
+						dataTempCount++;
+						
+						// Copy 0 to runLength bytes to the RLE data here
+						memcpy( dataTemp+dataTempCount , dataRun , runLength );
+						dataTempCount = dataTempCount + runLength;
+					}
+					else if(runType == 1)
+					{
+						// Set the RL byte high
+						*(dataTemp+dataTempCount) = runLength + 125;
+						dataTempCount++;
+						
+						// Only copy the first byte, since all the remaining values are identical
+						*(dataTemp+dataTempCount) = dataRun[0];
+						dataTempCount++;
+					}
+					
+					runCount++;
+					
+					// Copy 0 to runLength bytes to the RLE data here
+					dataRun[0] = dataByte;
+					runLength = 1;
+					runType = 0;
+				}
+			}
+		}
+		
+		// Copy the end of the last run
+		if(runLength > 0)
+		{
+			if(runType == 0)
+			{
+				// Set the RL byte low
+				*(dataTemp+dataTempCount) = runLength - 1;
+				dataTempCount++;
+				
+				// Copy 0 to runLength bytes to the RLE data here
+				memcpy( dataTemp+dataTempCount , dataRun , runLength );
+				dataTempCount = dataTempCount + runLength;
+			}
+			else if(runType == 1)
+			{
+				// Set the RL byte high
+				*(dataTemp+dataTempCount) = runLength + 125;
+				dataTempCount++;
+				
+				// Only copy the first byte, since all the remaining values are identical
+				*(dataTemp+dataTempCount) = dataRun[0];
+				dataTempCount++;
+			}
+			
+			runCount++;
+		}
+	}
+	
+	free(dataRun);
+	
+	// This block is for the final encoded data
+	(*dataPtrOut) = (icns_uint8_t *)malloc(dataTempCount);
+	if((*dataPtrOut) == NULL)
+	{
+		icns_print_err("icns_encode_rle24_data: Unable to allocate memory block of size: %d!\n",dataTempCount);
+		free(dataTemp);
+		return ICNS_STATUS_NO_MEMORY;
+	}
+	
+	*dataSizeOut = dataTempCount;
+	memcpy( (*dataPtrOut), dataTemp, dataTempCount);
+
+	free(dataTemp);
+	
+	return ICNS_STATUS_OK;
+}
+

src/add-ons/translators/icns/libicns/icns_utils.c

@@ -0,0 +1,763 @@
+/*
+File:       icns_utils.c
+Copyright (C) 2001-2012 Mathew Eis <[email protected]>
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, 
+Boston, MA 02110-1301, USA.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdarg.h>
+
+
+#include "icns.h"
+#include "icns_internals.h"
+
+
+/********* This variable is intentionally global ************/
+/********* scope is the internals of the icns library *******/
+#ifdef ICNS_DEBUG
+icns_bool_t	gShouldPrintErrors = 1;
+#else
+icns_bool_t	gShouldPrintErrors = 0;
+#endif
+
+icns_uint32_t icns_get_element_order(icns_type_t iconType)
+{
+	// Note: 1 bit mask is 'excluded' as
+	// 1 bit data and mask ID's are equal
+	// data stored in the same element
+	switch(iconType)
+	{
+	case ICNS_ICON_VERSION:
+		return 100;
+	case ICNS_1024x1024_32BIT_ARGB_DATA:
+		return 23;
+	case ICNS_512x512_32BIT_ARGB_DATA:
+		return 22;
+	case ICNS_256x256_32BIT_ARGB_DATA:
+		return 21;
+	case ICNS_128X128_8BIT_MASK:
+		return 20;
+	case ICNS_128X128_32BIT_DATA:
+		return 19;
+	case ICNS_48x48_8BIT_MASK:
+		return 18;
+	case ICNS_48x48_32BIT_DATA:
+		return 17;
+	case ICNS_48x48_8BIT_DATA:
+		return 16;
+	case ICNS_48x48_4BIT_DATA:
+		return 15;
+	case ICNS_48x48_1BIT_DATA:
+		return 14;
+	case ICNS_32x32_8BIT_MASK:
+		return 13;
+	case ICNS_32x32_32BIT_DATA:
+		return 12;
+	case ICNS_32x32_8BIT_DATA:
+		return 11;
+	case ICNS_32x32_4BIT_DATA:
+		return 10;
+	case ICNS_32x32_1BIT_DATA:
+		return 9;
+	case ICNS_16x16_8BIT_MASK:
+		return 8;
+	case ICNS_16x16_32BIT_DATA:
+		return 7;
+	case ICNS_16x16_8BIT_DATA:
+		return 6;
+	case ICNS_16x16_4BIT_DATA:
+		return 5;
+	case ICNS_16x16_1BIT_DATA:
+		return 4;
+	case ICNS_16x12_8BIT_DATA:
+		return 3;
+	case ICNS_16x12_4BIT_DATA:
+		return 2;
+	case ICNS_16x12_1BIT_DATA:
+		return 1;
+	case ICNS_TABLE_OF_CONTENTS:
+		return 0;
+	default:
+		return 1000;
+	}
+	
+	return 1000;
+}
+
+icns_type_t icns_get_mask_type_for_icon_type(icns_type_t iconType)
+{
+	switch(iconType)
+	{
+	// Obviously the TOC type has no mask
+	case ICNS_TABLE_OF_CONTENTS:
+		return ICNS_NULL_MASK;
+
+	// Obviously the version type has no mask
+	case ICNS_ICON_VERSION:
+		return ICNS_NULL_MASK;
+		
+	// 32-bit image types > 256x256 - no mask (mask is already in image)
+	case ICNS_1024x1024_32BIT_ARGB_DATA:
+		return ICNS_NULL_MASK;
+	case ICNS_512x512_32BIT_ARGB_DATA:
+		return ICNS_NULL_MASK;			
+	case ICNS_256x256_32BIT_ARGB_DATA:
+		return ICNS_NULL_MASK;		
+		
+	// 32-bit image types - 8-bit mask type
+	case ICNS_128X128_32BIT_DATA:
+		return ICNS_128X128_8BIT_MASK;	
+	case ICNS_48x48_32BIT_DATA:
+		return ICNS_48x48_8BIT_MASK;	
+	case ICNS_32x32_32BIT_DATA:
+		return ICNS_32x32_8BIT_MASK;
+	case ICNS_16x16_32BIT_DATA:
+		return ICNS_16x16_8BIT_MASK;
+		
+	// 8-bit image types - 1-bit mask types
+	case ICNS_48x48_8BIT_DATA:
+		return ICNS_48x48_1BIT_MASK;
+	case ICNS_32x32_8BIT_DATA:
+		return ICNS_32x32_1BIT_MASK;
+	case ICNS_16x16_8BIT_DATA:
+		return ICNS_16x16_1BIT_MASK;
+	case ICNS_16x12_8BIT_DATA:
+		return ICNS_16x12_1BIT_MASK;
+		
+	// 4 bit image types - 1-bit mask types
+	case ICNS_48x48_4BIT_DATA:
+		return ICNS_48x48_1BIT_MASK;
+	case ICNS_32x32_4BIT_DATA:
+		return ICNS_32x32_1BIT_MASK;
+	case ICNS_16x16_4BIT_DATA:
+		return ICNS_16x16_1BIT_MASK;
+	case ICNS_16x12_4BIT_DATA:
+		return ICNS_16x12_1BIT_MASK;
+		
+	// 1 bit image types - 1-bit mask types
+	case ICNS_48x48_1BIT_DATA:
+		return ICNS_48x48_1BIT_MASK;
+	case ICNS_32x32_1BIT_DATA:
+		return ICNS_32x32_1BIT_MASK;
+	case ICNS_16x16_1BIT_DATA:
+		return ICNS_16x16_1BIT_MASK;
+	case ICNS_16x12_1BIT_DATA:
+		return ICNS_16x12_1BIT_MASK;
+	default:
+		return ICNS_NULL_MASK;
+	}
+		
+	return ICNS_NULL_MASK;
+}
+
+icns_icon_info_t icns_get_image_info_for_type(icns_type_t iconType)
+{
+	icns_icon_info_t iconInfo;
+	
+	memset(&iconInfo,0,sizeof(iconInfo));
+	
+	if(iconType == ICNS_NULL_TYPE)
+	{
+		icns_print_err("icns_get_image_info_for_type: Unable to parse NULL type!\n");
+		return iconInfo;
+	}
+	
+	/*
+	#ifdef ICNS_DEBUG
+	{
+		char typeStr[5];
+		printf("Retrieving info for type '%s'...\n",icns_type_str(iconType,typeStr));
+	}
+	#endif
+	*/
+	
+	iconInfo.iconType = iconType;
+	
+	switch(iconType)
+	{
+	// TOC type
+	case ICNS_TABLE_OF_CONTENTS:
+		iconInfo.isImage = 0;
+		iconInfo.isMask = 0;
+		iconInfo.iconWidth = 0;
+		iconInfo.iconHeight = 0;
+		iconInfo.iconChannels = 0;
+		iconInfo.iconPixelDepth = 0;
+		iconInfo.iconBitDepth = 0;
+		break;
+	// Version type
+	case ICNS_ICON_VERSION:
+		iconInfo.isImage = 0;
+		iconInfo.isMask = 0;
+		iconInfo.iconWidth = 0;
+		iconInfo.iconHeight = 0;
+		iconInfo.iconChannels = 0;
+		iconInfo.iconPixelDepth = 0;
+		iconInfo.iconBitDepth = 0;
+		break;
+	// 32-bit image types
+	case ICNS_1024x1024_32BIT_ARGB_DATA:
+		iconInfo.isImage = 1;
+		iconInfo.isMask = 0;
+		iconInfo.iconWidth = 1024;
+		iconInfo.iconHeight = 1024;
+		iconInfo.iconChannels = 4;
+		iconInfo.iconPixelDepth = 8;
+		iconInfo.iconBitDepth = 32;
+		break;
+	case ICNS_512x512_32BIT_ARGB_DATA:
+		iconInfo.isImage = 1;
+		iconInfo.isMask = 0;
+		iconInfo.iconWidth = 512;
+		iconInfo.iconHeight = 512;
+		iconInfo.iconChannels = 4;
+		iconInfo.iconPixelDepth = 8;
+		iconInfo.iconBitDepth = 32;
+		break;
+	case ICNS_256x256_32BIT_ARGB_DATA:
+		iconInfo.isImage = 1;
+		iconInfo.isMask = 0;
+		iconInfo.iconWidth = 256;
+		iconInfo.iconHeight = 256;
+		iconInfo.iconChannels = 4;
+		iconInfo.iconPixelDepth = 8;
+		iconInfo.iconBitDepth = 32;
+		break;
+	case ICNS_128X128_32BIT_DATA:
+		iconInfo.isImage = 1;
+		iconInfo.isMask = 0;
+		iconInfo.iconWidth = 128;
+		iconInfo.iconHeight = 128;
+		iconInfo.iconChannels = 4;
+		iconInfo.iconPixelDepth = 8;
+		iconInfo.iconBitDepth = 32;
+		break;
+	case ICNS_48x48_32BIT_DATA:
+		iconInfo.isImage = 1;
+		iconInfo.isMask = 0;
+		iconInfo.iconWidth = 48;
+		iconInfo.iconHeight = 48;
+		iconInfo.iconChannels = 4;
+		iconInfo.iconPixelDepth = 8;
+		iconInfo.iconBitDepth = 32;	
+		break;
+	case ICNS_32x32_32BIT_DATA:
+		iconInfo.isImage = 1;
+		iconInfo.isMask = 0;
+		iconInfo.iconWidth = 32;
+		iconInfo.iconHeight = 32;
+		iconInfo.iconChannels = 4;
+		iconInfo.iconPixelDepth = 8;
+		iconInfo.iconBitDepth = 32;
+		break;
+	case ICNS_16x16_32BIT_DATA:
+		iconInfo.isImage = 1;
+		iconInfo.isMask = 0;
+		iconInfo.iconWidth = 16;
+		iconInfo.iconHeight = 16;
+		iconInfo.iconChannels = 4;
+		iconInfo.iconPixelDepth = 8;
+		iconInfo.iconBitDepth = 32;
+		break;
+		
+	// 8-bit mask types
+	case ICNS_128X128_8BIT_MASK:
+		iconInfo.isImage = 0;
+		iconInfo.isMask = 1;
+		iconInfo.iconWidth = 128;
+		iconInfo.iconHeight = 128;
+		iconInfo.iconChannels = 1;
+		iconInfo.iconPixelDepth = 8;
+		iconInfo.iconBitDepth = 8;
+		break;
+	case ICNS_48x48_8BIT_MASK:
+		iconInfo.isImage = 0;
+		iconInfo.isMask = 1;
+		iconInfo.iconWidth = 48;
+		iconInfo.iconHeight = 48;
+		iconInfo.iconChannels = 1;
+		iconInfo.iconPixelDepth = 8;
+		iconInfo.iconBitDepth = 8;
+		break;
+	case ICNS_32x32_8BIT_MASK:
+		iconInfo.isImage = 0;
+		iconInfo.isMask = 1;
+		iconInfo.iconWidth = 32;
+		iconInfo.iconHeight = 32;
+		iconInfo.iconChannels = 1;
+		iconInfo.iconPixelDepth = 8;
+		iconInfo.iconBitDepth = 8;
+		break;
+	case ICNS_16x16_8BIT_MASK:
+		iconInfo.isImage = 0;
+		iconInfo.isMask = 1;
+		iconInfo.iconWidth = 16;
+		iconInfo.iconHeight = 16;
+		iconInfo.iconChannels = 1;
+		iconInfo.iconPixelDepth = 8;
+		iconInfo.iconBitDepth = 8;
+		break;
+	
+	// 8-bit image types
+	case ICNS_48x48_8BIT_DATA:
+		iconInfo.isImage = 1;
+		iconInfo.isMask = 0;
+		iconInfo.iconWidth = 48;
+		iconInfo.iconHeight = 48;
+		iconInfo.iconChannels = 1;
+		iconInfo.iconPixelDepth = 8;
+		iconInfo.iconBitDepth = 8;
+		break;
+	case ICNS_32x32_8BIT_DATA:
+		iconInfo.isImage = 1;
+		iconInfo.isMask = 0;
+		iconInfo.iconWidth = 32;
+		iconInfo.iconHeight = 32;
+		iconInfo.iconChannels = 1;
+		iconInfo.iconPixelDepth = 8;
+		iconInfo.iconBitDepth = 8;
+		break;
+	case ICNS_16x16_8BIT_DATA:
+		iconInfo.isImage = 1;
+		iconInfo.isMask = 0;
+		iconInfo.iconWidth = 16;
+		iconInfo.iconHeight = 16;
+		iconInfo.iconChannels = 1;
+		iconInfo.iconPixelDepth = 8;
+		iconInfo.iconBitDepth = 8;
+		break;
+	case ICNS_16x12_8BIT_DATA:
+		iconInfo.isImage = 1;
+		iconInfo.isMask = 0;
+		iconInfo.iconWidth = 16;
+		iconInfo.iconHeight = 12;
+		iconInfo.iconChannels = 1;
+		iconInfo.iconPixelDepth = 8;
+		iconInfo.iconBitDepth = 8;
+		break;
+		
+	// 4 bit image types
+	case ICNS_48x48_4BIT_DATA:
+		iconInfo.isImage = 1;
+		iconInfo.isMask = 0;
+		iconInfo.iconWidth = 48;
+		iconInfo.iconHeight = 48;
+		iconInfo.iconChannels = 1;
+		iconInfo.iconPixelDepth = 4;
+		iconInfo.iconBitDepth = 4;
+		break;
+	case ICNS_32x32_4BIT_DATA:
+		iconInfo.isImage = 1;
+		iconInfo.isMask = 0;
+		iconInfo.iconWidth = 32;
+		iconInfo.iconHeight = 32;
+		iconInfo.iconChannels = 1;
+		iconInfo.iconPixelDepth = 4;
+		iconInfo.iconBitDepth = 4;
+		break;
+	case ICNS_16x16_4BIT_DATA:
+		iconInfo.isImage = 1;
+		iconInfo.isMask = 0;
+		iconInfo.iconWidth = 16;
+		iconInfo.iconHeight = 16;
+		iconInfo.iconChannels = 1;
+		iconInfo.iconPixelDepth = 4;
+		iconInfo.iconBitDepth = 4;
+		break;
+	case ICNS_16x12_4BIT_DATA:
+		iconInfo.isImage = 1;
+		iconInfo.isMask = 0;
+		iconInfo.iconWidth = 16;
+		iconInfo.iconHeight = 12;
+		iconInfo.iconChannels = 1;
+		iconInfo.iconPixelDepth = 4;
+		iconInfo.iconBitDepth = 4;
+		break;
+		
+	// 1 bit image types - same as mask typess
+	case ICNS_48x48_1BIT_DATA:
+		iconInfo.isImage = 1;
+		iconInfo.isMask = 1;
+		iconInfo.iconWidth = 48;
+		iconInfo.iconHeight = 48;
+		iconInfo.iconChannels = 1;
+		iconInfo.iconPixelDepth = 1;
+		iconInfo.iconBitDepth = 1;
+		break;
+	case ICNS_32x32_1BIT_DATA:
+		iconInfo.isImage = 1;
+		iconInfo.isMask = 1;
+		iconInfo.iconWidth = 32;
+		iconInfo.iconHeight = 32;
+		iconInfo.iconChannels = 1;
+		iconInfo.iconPixelDepth = 1;
+		iconInfo.iconBitDepth = 1;
+		break;
+	case ICNS_16x16_1BIT_DATA:
+		iconInfo.isImage = 1;
+		iconInfo.isMask = 1;
+		iconInfo.iconWidth = 16;
+		iconInfo.iconHeight = 16;
+		iconInfo.iconChannels = 1;
+		iconInfo.iconPixelDepth = 1;
+		iconInfo.iconBitDepth = 1;
+		break;
+	case ICNS_16x12_1BIT_DATA:
+		iconInfo.isImage = 1;
+		iconInfo.isMask = 1;
+		iconInfo.iconWidth = 16;
+		iconInfo.iconHeight = 12;
+		iconInfo.iconChannels = 1;
+		iconInfo.iconPixelDepth = 1;
+		iconInfo.iconBitDepth = 1;
+		break;
+	default:
+		{
+			char typeStr[5];
+			icns_print_err("icns_get_image_info_for_type: Unable to parse icon type '%s'\n",icns_type_str(iconType,typeStr));
+			iconInfo.iconType = ICNS_NULL_TYPE;
+		}
+		break;
+	}
+	
+	iconInfo.iconRawDataSize = iconInfo.iconHeight * iconInfo.iconWidth * iconInfo.iconBitDepth / ICNS_BYTE_BITS;
+	
+	/*
+	#ifdef ICNS_DEBUG
+	{
+		char typeStr[5];
+		printf("  type is: '%s'\n",icns_type_str(iconInfo.iconType));
+		printf("  width is: %d\n",iconInfo.iconWidth);
+		printf("  height is: %d\n",iconInfo.iconHeight);
+		printf("  channels are: %d\n",iconInfo.iconChannels);
+		printf("  pixel depth is: %d\n",iconInfo.iconPixelDepth);
+		printf("  bit depth is: %d\n",iconInfo.iconBitDepth);
+		printf("  data size is: %d\n",(int)iconInfo.iconRawDataSize);
+	}
+	#endif
+	*/
+	
+	return iconInfo;
+}
+
+icns_type_t	icns_get_type_from_image_info(icns_icon_info_t iconInfo)
+{
+	// Give our best effort to returning a type from the given information
+	// But there is only so much we can't work with...
+	if( (iconInfo.isImage == 0) && (iconInfo.isMask == 0) )
+		return ICNS_NULL_TYPE;
+	
+	if( (iconInfo.iconWidth == 0) || (iconInfo.iconHeight == 0) )
+	{
+		// For some really small sizes, we can tell from just the data size...
+		switch(iconInfo.iconRawDataSize)
+		{
+		case 24:
+			// Data is too small to have both
+			if( (iconInfo.isImage == 1) && (iconInfo.isMask == 1) )
+				return ICNS_NULL_TYPE;
+			if( iconInfo.isImage == 1 )
+				return ICNS_16x12_1BIT_DATA;
+			if( iconInfo.isMask == 1 )
+				return ICNS_16x12_1BIT_MASK;
+			break;
+		case 32:
+			// Data is too small to have both
+			if( (iconInfo.isImage == 1) && (iconInfo.isMask == 1) )
+				return ICNS_NULL_TYPE;
+			if( iconInfo.isImage == 1 )
+				return ICNS_16x16_1BIT_DATA;
+			if( iconInfo.isMask == 1 )
+				return ICNS_16x16_1BIT_MASK;
+			break;
+		default:
+			return ICNS_NULL_TYPE;
+		}
+	}
+	
+	// We need the bit depth to determine the type for sizes < 128
+	if( (iconInfo.iconBitDepth == 0) && (iconInfo.iconWidth < 128 || iconInfo.iconHeight < 128) )
+	{
+		if(iconInfo.iconPixelDepth == 0 || iconInfo.iconChannels == 0)
+			return ICNS_NULL_TYPE;
+		else
+			iconInfo.iconBitDepth = iconInfo.iconPixelDepth * iconInfo.iconChannels;
+	}
+	
+	// Special case for these mini icons
+	if(iconInfo.iconWidth == 16 && iconInfo.iconHeight == 12)
+	{
+		switch(iconInfo.iconBitDepth)
+		{
+		case 1:
+			if(iconInfo.isImage == 1)
+				return ICNS_16x12_1BIT_DATA;
+			if(iconInfo.isMask == 1)
+				return ICNS_16x12_1BIT_MASK;
+			break;
+		case 4:
+			return ICNS_16x12_4BIT_DATA;
+			break;
+		case 8:
+			return ICNS_16x12_8BIT_DATA;
+			break;
+		default:
+			return ICNS_NULL_TYPE;
+			break;
+		}
+	}
+	
+	// Width must equal hieght from here on...
+	if(iconInfo.iconWidth != iconInfo.iconHeight)
+		return ICNS_NULL_TYPE;
+	
+	
+	switch(iconInfo.iconWidth)
+	{
+	case 16:
+		switch(iconInfo.iconBitDepth)
+		{
+		case 1:
+			if(iconInfo.isImage == 1)
+				return ICNS_16x16_1BIT_DATA;
+			if(iconInfo.isMask == 1)
+				return ICNS_16x16_1BIT_MASK;
+			break;
+		case 4:
+			return ICNS_16x16_4BIT_DATA;
+			break;
+		case 8:
+			if(iconInfo.isImage == 1)
+				return ICNS_16x16_8BIT_DATA;
+			if(iconInfo.isMask == 1)
+				return ICNS_16x16_8BIT_MASK;
+			break;
+		case 32:
+			return ICNS_16x16_32BIT_DATA;
+			break;
+		default:
+			return ICNS_NULL_TYPE;
+			break;
+		}
+		break;
+	case 32:
+		switch(iconInfo.iconBitDepth)
+		{
+		case 1:
+			if(iconInfo.isImage == 1)
+				return ICNS_32x32_1BIT_DATA;
+			if(iconInfo.isMask == 1)
+				return ICNS_32x32_1BIT_MASK;
+			break;
+		case 4:
+			return ICNS_32x32_4BIT_DATA;
+			break;
+		case 8:
+			if(iconInfo.isImage == 1)
+				return ICNS_32x32_8BIT_DATA;
+			if(iconInfo.isMask == 1)
+				return ICNS_32x32_8BIT_MASK;
+			break;
+		case 32:
+			return ICNS_32x32_32BIT_DATA;
+			break;
+		default:
+			return ICNS_NULL_TYPE;
+			break;
+		}
+		break;
+	case 48:
+		switch(iconInfo.iconBitDepth)
+		{
+		case 1:
+			if(iconInfo.isImage == 1)
+				return ICNS_48x48_1BIT_DATA;
+			if(iconInfo.isMask == 1)
+				return ICNS_48x48_1BIT_MASK;
+			break;
+		case 4:
+			return ICNS_48x48_4BIT_DATA;
+			break;
+		case 8:
+			if(iconInfo.isImage == 1)
+				return ICNS_48x48_8BIT_DATA;
+			if(iconInfo.isMask == 1)
+				return ICNS_48x48_8BIT_MASK;
+			break;
+		case 32:
+			return ICNS_48x48_32BIT_DATA;
+			break;
+		default:
+			return ICNS_NULL_TYPE;
+			break;
+		}
+		break;
+	case 128:
+		if(iconInfo.isImage == 1 || iconInfo.iconBitDepth == 32)
+			return ICNS_128X128_32BIT_DATA;
+		if(iconInfo.isMask == 1 || iconInfo.iconBitDepth == 8)
+			return ICNS_128X128_8BIT_MASK;
+		break;
+	case 256:
+		return ICNS_256x256_32BIT_ARGB_DATA;
+		break;
+	case 512:
+		return ICNS_512x512_32BIT_ARGB_DATA;
+		break;
+	case 1024:
+		return ICNS_1024x1024_32BIT_ARGB_DATA;
+		break;
+		
+	}
+	
+	return ICNS_NULL_TYPE;
+}
+
+icns_type_t	icns_get_type_from_image(icns_image_t iconImage)
+{
+	icns_icon_info_t		iconInfo;
+	
+	iconInfo.iconWidth = iconImage.imageWidth;
+	iconInfo.iconHeight = iconImage.imageHeight;
+	iconInfo.iconChannels = iconImage.imageChannels;
+	iconInfo.iconPixelDepth = iconImage.imagePixelDepth;
+	iconInfo.iconBitDepth = iconInfo.iconPixelDepth * iconInfo.iconChannels;
+	iconInfo.iconRawDataSize = iconImage.imageDataSize;
+	
+	if(iconInfo.iconBitDepth == 1)
+	{
+		int	flatSize = ((iconInfo.iconWidth * iconInfo.iconHeight) / 8);
+		if(iconInfo.iconRawDataSize == (flatSize * 2) )
+		{
+		iconInfo.isImage = 1;
+		iconInfo.isMask = 1;
+		}
+		else
+		{
+		iconInfo.isImage = 1;
+		iconInfo.isMask = 0;
+		}
+	}
+	else
+	{
+		iconInfo.isImage = 1;
+		iconInfo.isMask = 0;
+	}
+	
+	return icns_get_type_from_image_info(iconInfo);
+}
+
+icns_type_t	icns_get_type_from_mask(icns_image_t iconImage)
+{
+	icns_icon_info_t		iconInfo;
+	
+	iconInfo.iconWidth = iconImage.imageWidth;
+	iconInfo.iconHeight = iconImage.imageHeight;
+	iconInfo.iconChannels = iconImage.imageChannels;
+	iconInfo.iconPixelDepth = iconImage.imagePixelDepth;
+	iconInfo.iconBitDepth = iconInfo.iconPixelDepth * iconInfo.iconChannels;
+	iconInfo.iconRawDataSize = iconImage.imageDataSize;
+	
+	if(iconInfo.iconBitDepth == 1)
+	{
+		int	flatSize = ((iconInfo.iconWidth * iconInfo.iconHeight) / 8);
+		if(iconInfo.iconRawDataSize == (flatSize * 2) )
+		{
+		iconInfo.isImage = 1;
+		iconInfo.isMask = 1;
+		}
+		else
+		{
+		iconInfo.isImage = 0;
+		iconInfo.isMask = 1;
+		}
+	}
+	else
+	{
+		iconInfo.isImage = 0;
+		iconInfo.isMask = 1;
+	}
+	
+	return icns_get_type_from_image_info(iconInfo);
+}
+
+icns_bool_t icns_types_equal(icns_type_t typeA,icns_type_t typeB)
+{
+	if(memcmp(&typeA, &typeB, sizeof(icns_type_t)) == 0)
+		return 1;
+	else
+		return 0;
+}
+
+// This is is largely for conveniance and readability
+icns_bool_t icns_types_not_equal(icns_type_t typeA,icns_type_t typeB)
+{
+	if(memcmp(&typeA, &typeB, sizeof(icns_type_t)) != 0)
+		return 1;
+	else
+		return 0;
+}
+
+const char * icns_type_str(icns_type_t type, char *strbuf)
+{
+	if(strbuf != NULL)
+	{
+		uint32_t v = *((uint32_t *)(&type));
+		strbuf[0] = v >> 24;
+		strbuf[1] = v >> 16;
+		strbuf[2] = v >> 8;
+		strbuf[3] = v;
+		strbuf[4] = 0;
+		return (const char *)strbuf;
+	}
+	return NULL;
+}
+
+void icns_set_print_errors(icns_bool_t shouldPrint)
+{
+	#ifdef ICNS_DEBUG
+		if(shouldPrint == 0) {
+			icns_print_err("Debugging enabled - error message status cannot be disabled!\n");
+		}
+	#else
+		gShouldPrintErrors = shouldPrint;
+	#endif
+}
+
+void icns_print_err(const char *template, ...)
+{
+	va_list ap;
+	
+	#ifdef ICNS_DEBUG
+	printf ( "libicns: ");
+	va_start (ap, template);
+	vprintf (template, ap);
+	va_end (ap);
+	#else
+	if(gShouldPrintErrors)
+	{
+		fprintf (stderr, "libicns: ");
+		va_start (ap, template);
+		vfprintf (stderr, template, ap);
+		va_end (ap);
+	}
+	#endif
+}
+

src/add-ons/translators/icns/main.cpp

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2005-2006, Axel Dörfler, [email protected]. All rights reserved.
+ * Copyright 2012, Gerasim Troeglazov, [email protected]. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+
+#include <Application.h>
+
+#include "ICNSTranslator.h"
+#include "TranslatorWindow.h"
+
+int
+main(int /*argc*/, char ** /*argv*/)
+{
+	BApplication app("application/x-vnd.Haiku-ICNSTranslator");
+
+	status_t result;
+	result = LaunchTranslatorWindow(new ICNSTranslator, 
+		"ICNS Settings", BRect(0, 0, 320, 200));
+	if (result != B_OK)
+		return 1;
+
+	app.Run();
+	return 0;
+}
+

src/add-ons/translators/icns/openjpeg/LICENSE

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2002-2012, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2012, Professor Benoit Macq
+ * Copyright (c) 2003-2012, Antonin Descampe
+ * Copyright (c) 2003-2009, Francois-Olivier Devaux
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2001-2003, David Janssens
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */

src/add-ons/translators/icns/openjpeg/README

@@ -0,0 +1,25 @@
+
+OPENJPEG LIBRARY and APPLICATIONS
+----------------------------------
+
+Details on folders hierarchy:
+
+* libopenjpeg: contains the sources of the openjpeg library
+    * jpwl: contains the additional sources if you want to build a JPWL-flavoured library.
+* applications: contains all applications that use the openjpeg library
+    * common: common files to all applications
+    * codec: a basic codec
+    * mj2: motion jpeg 2000 executables
+    * JavaOpenJPEG: java jni to use openjpeg in a java program
+    * jpip: complete client-server architecture for remote browsing of jpeg 2000 images. See corresponding README for more details.
+    * OPJViewer: gui for displaying j2k files (based on wxWidget)
+* thirdparty: thirdparty libraries used by some applications. These libraries will be built only if there are not found on the system. Note that libopenjpeg itself does not have any dependency.
+* doc: doxygen documentation setup file and man pages
+* tests: configuration files and utilities for the openjpeg test suite. All test images are located in 'http://openjpeg.googlecode.com/svn/data' folder.
+* CMake: cmake related files
+* m4: autotools related files
+
+see LICENSE for license and copyright information.
+see INSTALL for installation procedures.
+see NEWS for user visible changes in successive releases.
+see CHANGES for per-revision changes.

src/add-ons/translators/icns/openjpeg/bio.c

@@ -0,0 +1,187 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "opj_includes.h"
+
+/** @defgroup BIO BIO - Individual bit input-output stream */
+/*@{*/
+
+/** @name Local static functions */
+/*@{*/
+
+/**
+Write a bit
+@param bio BIO handle
+@param b Bit to write (0 or 1)
+*/
+static void bio_putbit(opj_bio_t *bio, int b);
+/**
+Read a bit
+@param bio BIO handle
+@return Returns the read bit
+*/
+static int bio_getbit(opj_bio_t *bio);
+/**
+Write a byte
+@param bio BIO handle
+@return Returns 0 if successful, returns 1 otherwise
+*/
+static int bio_byteout(opj_bio_t *bio);
+/**
+Read a byte
+@param bio BIO handle
+@return Returns 0 if successful, returns 1 otherwise
+*/
+static int bio_bytein(opj_bio_t *bio);
+
+/*@}*/
+
+/*@}*/
+
+/* 
+==========================================================
+   local functions
+==========================================================
+*/
+
+static int bio_byteout(opj_bio_t *bio) {
+	bio->buf = (bio->buf << 8) & 0xffff;
+	bio->ct = bio->buf == 0xff00 ? 7 : 8;
+	if (bio->bp >= bio->end) {
+		return 1;
+	}
+	*bio->bp++ = bio->buf >> 8;
+	return 0;
+}
+
+static int bio_bytein(opj_bio_t *bio) {
+	bio->buf = (bio->buf << 8) & 0xffff;
+	bio->ct = bio->buf == 0xff00 ? 7 : 8;
+	if (bio->bp >= bio->end) {
+		return 1;
+	}
+	bio->buf |= *bio->bp++;
+	return 0;
+}
+
+static void bio_putbit(opj_bio_t *bio, int b) {
+	if (bio->ct == 0) {
+		bio_byteout(bio);
+	}
+	bio->ct--;
+	bio->buf |= b << bio->ct;
+}
+
+static int bio_getbit(opj_bio_t *bio) {
+	if (bio->ct == 0) {
+		bio_bytein(bio);
+	}
+	bio->ct--;
+	return (bio->buf >> bio->ct) & 1;
+}
+
+/* 
+==========================================================
+   Bit Input/Output interface
+==========================================================
+*/
+
+opj_bio_t* bio_create(void) {
+	opj_bio_t *bio = (opj_bio_t*)opj_malloc(sizeof(opj_bio_t));
+	return bio;
+}
+
+void bio_destroy(opj_bio_t *bio) {
+	if(bio) {
+		opj_free(bio);
+	}
+}
+
+int bio_numbytes(opj_bio_t *bio) {
+	return (bio->bp - bio->start);
+}
+
+void bio_init_enc(opj_bio_t *bio, unsigned char *bp, int len) {
+	bio->start = bp;
+	bio->end = bp + len;
+	bio->bp = bp;
+	bio->buf = 0;
+	bio->ct = 8;
+}
+
+void bio_init_dec(opj_bio_t *bio, unsigned char *bp, int len) {
+	bio->start = bp;
+	bio->end = bp + len;
+	bio->bp = bp;
+	bio->buf = 0;
+	bio->ct = 0;
+}
+
+void bio_write(opj_bio_t *bio, int v, int n) {
+	int i;
+	for (i = n - 1; i >= 0; i--) {
+		bio_putbit(bio, (v >> i) & 1);
+	}
+}
+
+int bio_read(opj_bio_t *bio, int n) {
+	int i, v;
+	v = 0;
+	for (i = n - 1; i >= 0; i--) {
+		v += bio_getbit(bio) << i;
+	}
+	return v;
+}
+
+int bio_flush(opj_bio_t *bio) {
+	bio->ct = 0;
+	if (bio_byteout(bio)) {
+		return 1;
+	}
+	if (bio->ct == 7) {
+		bio->ct = 0;
+		if (bio_byteout(bio)) {
+			return 1;
+		}
+	}
+	return 0;
+}
+
+int bio_inalign(opj_bio_t *bio) {
+	bio->ct = 0;
+	if ((bio->buf & 0xff) == 0xff) {
+		if (bio_bytein(bio)) {
+			return 1;
+		}
+		bio->ct = 0;
+	}
+	return 0;
+}

src/add-ons/translators/icns/openjpeg/bio.h

@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __BIO_H
+#define __BIO_H
+/** 
+@file bio.h
+@brief Implementation of an individual bit input-output (BIO)
+
+The functions in BIO.C have for goal to realize an individual bit input - output.
+*/
+
+/** @defgroup BIO BIO - Individual bit input-output stream */
+/*@{*/
+
+/**
+Individual bit input-output stream (BIO)
+*/
+typedef struct opj_bio {
+	/** pointer to the start of the buffer */
+	unsigned char *start;
+	/** pointer to the end of the buffer */
+	unsigned char *end;
+	/** pointer to the present position in the buffer */
+	unsigned char *bp;
+	/** temporary place where each byte is read or written */
+	unsigned int buf;
+	/** coder : number of bits free to write. decoder : number of bits read */
+	int ct;
+} opj_bio_t;
+
+/** @name Exported functions */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+/**
+Create a new BIO handle 
+@return Returns a new BIO handle if successful, returns NULL otherwise
+*/
+opj_bio_t* bio_create(void);
+/**
+Destroy a previously created BIO handle
+@param bio BIO handle to destroy
+*/
+void bio_destroy(opj_bio_t *bio);
+/**
+Number of bytes written.
+@param bio BIO handle
+@return Returns the number of bytes written
+*/
+int bio_numbytes(opj_bio_t *bio);
+/**
+Init encoder
+@param bio BIO handle
+@param bp Output buffer
+@param len Output buffer length 
+*/
+void bio_init_enc(opj_bio_t *bio, unsigned char *bp, int len);
+/**
+Init decoder
+@param bio BIO handle
+@param bp Input buffer
+@param len Input buffer length 
+*/
+void bio_init_dec(opj_bio_t *bio, unsigned char *bp, int len);
+/**
+Write bits
+@param bio BIO handle
+@param v Value of bits
+@param n Number of bits to write
+*/
+void bio_write(opj_bio_t *bio, int v, int n);
+/**
+Read bits
+@param bio BIO handle
+@param n Number of bits to read 
+@return Returns the corresponding read number
+*/
+int bio_read(opj_bio_t *bio, int n);
+/**
+Flush bits
+@param bio BIO handle
+@return Returns 1 if successful, returns 0 otherwise
+*/
+int bio_flush(opj_bio_t *bio);
+/**
+Passes the ending bits (coming from flushing)
+@param bio BIO handle
+@return Returns 1 if successful, returns 0 otherwise
+*/
+int bio_inalign(opj_bio_t *bio);
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __BIO_H */
+

src/add-ons/translators/icns/openjpeg/cidx_manager.c

@@ -0,0 +1,211 @@
+/*
+ * $Id: cidx_manager.c 897 2011-08-28 21:43:57Z [email protected] $
+ *
+ * Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2011, Professor Benoit Macq
+ * Copyright (c) 2003-2004, Yannick Verschueren
+ * Copyright (c) 2010-2011, Kaori Hagihara
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "opj_includes.h"
+
+
+/* 
+ * Write CPTR Codestream finder box
+ *
+ * @param[in] coff offset of j2k codestream
+ * @param[in] clen length of j2k codestream
+ * @param[in] cio  file output handle
+ */
+void write_cptr(int coff, int clen, opj_cio_t *cio);
+
+
+/* 
+ * Write main header index table (box)
+ *
+ * @param[in] coff offset of j2k codestream
+ * @param[in] cstr_info codestream information
+ * @param[in] cio  file output handle
+ * @return         length of mainmhix box
+ */
+int write_mainmhix( int coff, opj_codestream_info_t cstr_info, opj_cio_t *cio);
+
+
+/* 
+ * Check if EPH option is used
+ *
+ * @param[in] coff    offset of j2k codestream
+ * @param[in] markers marker information
+ * @param[in] marknum number of markers
+ * @param[in] cio     file output handle
+ * @return            true if EPH is used
+ */
+opj_bool check_EPHuse( int coff, opj_marker_info_t *markers, int marknum, opj_cio_t *cio);
+
+
+int write_cidx( int offset, opj_cio_t *cio, opj_image_t *image, opj_codestream_info_t cstr_info, int j2klen)
+{
+  int len, i, lenp;
+  opj_jp2_box_t *box;
+  int num_box = 0;
+  opj_bool  EPHused;
+  (void)image; /* unused ? */
+
+  lenp = -1;
+  box = (opj_jp2_box_t *)opj_calloc( 32, sizeof(opj_jp2_box_t));
+
+  for (i=0;i<2;i++){
+  
+    if(i)
+      cio_seek( cio, lenp);
+
+    lenp = cio_tell( cio);
+
+    cio_skip( cio, 4);              /* L [at the end] */
+    cio_write( cio, JPIP_CIDX, 4);  /* CIDX           */
+    write_cptr( offset, cstr_info.codestream_size, cio);
+
+    write_manf( i, num_box, box, cio);
+    
+    num_box = 0;
+    box[num_box].length = write_mainmhix( offset, cstr_info, cio);
+    box[num_box].type = JPIP_MHIX;
+    num_box++;
+
+    box[num_box].length = write_tpix( offset, cstr_info, j2klen, cio);
+    box[num_box].type = JPIP_TPIX;
+    num_box++;
+      
+    box[num_box].length = write_thix( offset, cstr_info, cio);
+    box[num_box].type = JPIP_THIX;
+    num_box++;
+
+    EPHused = check_EPHuse( offset, cstr_info.marker, cstr_info.marknum, cio);
+      
+    box[num_box].length = write_ppix( offset, cstr_info, EPHused, j2klen, cio);
+    box[num_box].type = JPIP_PPIX;
+    num_box++;
+    
+    box[num_box].length = write_phix( offset, cstr_info, EPHused, j2klen, cio);
+    box[num_box].type = JPIP_PHIX;
+    num_box++;
+      
+    len = cio_tell( cio)-lenp;
+    cio_seek( cio, lenp);
+    cio_write( cio, len, 4);        /* L             */
+    cio_seek( cio, lenp+len);
+  }
+
+  opj_free( box);
+  
+  return len;
+}
+
+void write_cptr(int coff, int clen, opj_cio_t *cio)
+{
+  int len, lenp;
+
+  lenp = cio_tell( cio);
+  cio_skip( cio, 4);               /* L [at the end]     */
+  cio_write( cio, JPIP_CPTR, 4);   /* T                  */
+  cio_write( cio, 0, 2);           /* DR  A PRECISER !!  */
+  cio_write( cio, 0, 2);           /* CONT               */
+  cio_write( cio, coff, 8);    /* COFF A PRECISER !! */
+  cio_write( cio, clen, 8);    /* CLEN               */
+  len = cio_tell( cio) - lenp;
+  cio_seek( cio, lenp);
+  cio_write( cio, len, 4);         /* L                  */
+  cio_seek( cio, lenp+len);
+}
+
+void write_manf(int second, int v, opj_jp2_box_t *box, opj_cio_t *cio)
+{
+  int len, lenp, i;
+  
+  lenp = cio_tell( cio); 
+  cio_skip( cio, 4);                         /* L [at the end]                    */
+  cio_write( cio, JPIP_MANF,4);              /* T                                 */
+
+  if (second){                          /* Write only during the second pass */
+    for( i=0; i<v; i++){
+      cio_write( cio, box[i].length, 4);  /* Box length                     */ 
+      cio_write( cio, box[i].type, 4); /* Box type                       */
+    }
+  }
+
+  len = cio_tell( cio) - lenp;
+  cio_seek( cio, lenp);
+  cio_write( cio, len, 4);                   /* L                                 */
+  cio_seek( cio, lenp+len);
+}
+
+int write_mainmhix( int coff, opj_codestream_info_t cstr_info, opj_cio_t *cio)
+{
+  int i;
+  int len, lenp;
+  
+  lenp = cio_tell( cio);
+  cio_skip( cio, 4);                               /* L [at the end]                    */
+  cio_write( cio, JPIP_MHIX, 4);                   /* MHIX                              */
+
+  cio_write( cio, cstr_info.main_head_end-cstr_info.main_head_start+1, 8);        /* TLEN                              */
+
+  for(i = 1; i < cstr_info.marknum; i++){    /* Marker restricted to 1 apparition, skip SOC marker */
+    cio_write( cio, cstr_info.marker[i].type, 2);
+    cio_write( cio, 0, 2);
+    cio_write( cio, cstr_info.marker[i].pos-coff, 8);
+    cio_write( cio, cstr_info.marker[i].len, 2);
+  }
+
+  len = cio_tell( cio) - lenp;
+  cio_seek( cio, lenp);
+  cio_write( cio, len, 4);        /* L           */
+  cio_seek( cio, lenp+len);
+  
+  return len;
+}
+
+opj_bool check_EPHuse( int coff, opj_marker_info_t *markers, int marknum, opj_cio_t *cio)
+{
+  opj_bool EPHused = OPJ_FALSE;
+  int i=0;
+  int org_pos;
+  unsigned int Scod;
+
+  for(i = 0; i < marknum; i++){
+    if( markers[i].type == J2K_MS_COD){
+      org_pos = cio_tell( cio);
+      cio_seek( cio, coff+markers[i].pos+2);
+      
+      Scod = cio_read( cio, 1);
+      if( ((Scod >> 2) & 1))
+	EPHused = OPJ_TRUE;
+      cio_seek( cio, org_pos);
+
+      break;
+    }
+  }    
+  return EPHused;
+}

src/add-ons/translators/icns/openjpeg/cidx_manager.h

@@ -0,0 +1,56 @@
+/*
+ * $Id: cidx_manager.h 897 2011-08-28 21:43:57Z [email protected] $
+ *
+ * Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2011, Professor Benoit Macq
+ * Copyright (c) 2003-2004, Yannick Verschueren
+ * Copyright (c) 2010-2011, Kaori Hagihara
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*! \file
+ *  \brief Modification of jpip.h from 2KAN indexer
+ */
+
+
+#ifndef  CIDX_MANAGER_H_
+# define CIDX_MANAGER_H_
+
+#include "openjpeg.h"
+
+
+/* 
+ * Write Codestream index box (superbox)
+ *
+ * @param[in] offset    offset of j2k codestream
+ * @param[in] cio       file output handle
+ * @param[in] image     image data
+ * @param[in] cstr_info codestream information
+ * @param[in] j2klen    length of j2k codestream
+ * @return              length of cidx box
+ */
+int write_cidx( int offset, opj_cio_t *cio, opj_image_t *image, opj_codestream_info_t cstr_info, int j2klen);
+
+
+#endif      /* !CIDX_MANAGER_H_ */

src/add-ons/translators/icns/openjpeg/cio.c

@@ -0,0 +1,191 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "opj_includes.h"
+
+/* ----------------------------------------------------------------------- */
+
+opj_cio_t* OPJ_CALLCONV opj_cio_open(opj_common_ptr cinfo, unsigned char *buffer, int length) {
+	opj_cp_t *cp = NULL;
+	opj_cio_t *cio = (opj_cio_t*)opj_malloc(sizeof(opj_cio_t));
+	if(!cio) return NULL;
+	cio->cinfo = cinfo;
+	if(buffer && length) {
+		/* wrap a user buffer containing the encoded image */
+		cio->openmode = OPJ_STREAM_READ;
+		cio->buffer = buffer;
+		cio->length = length;
+	}
+	else if(!buffer && !length && cinfo) {
+		/* allocate a buffer for the encoded image */
+		cio->openmode = OPJ_STREAM_WRITE;
+		switch(cinfo->codec_format) {
+			case CODEC_J2K:
+				cp = ((opj_j2k_t*)cinfo->j2k_handle)->cp;
+				break;
+			case CODEC_JP2:
+				cp = ((opj_jp2_t*)cinfo->jp2_handle)->j2k->cp;
+				break;
+			default:
+				opj_free(cio);
+				return NULL;
+		}
+		cio->length = (unsigned int) (0.1625 * cp->img_size + 2000); /* 0.1625 = 1.3/8 and 2000 bytes as a minimum for headers */
+		cio->buffer = (unsigned char *)opj_malloc(cio->length);
+		if(!cio->buffer) {
+			opj_event_msg(cio->cinfo, EVT_ERROR, "Error allocating memory for compressed bitstream\n");
+			opj_free(cio);
+			return NULL;
+		}
+	}
+	else {
+		opj_free(cio);
+		return NULL;
+	}
+
+	/* Initialize byte IO */
+	cio->start = cio->buffer;
+	cio->end = cio->buffer + cio->length;
+	cio->bp = cio->buffer;
+
+	return cio;
+}
+
+void OPJ_CALLCONV opj_cio_close(opj_cio_t *cio) {
+	if(cio) {
+		if(cio->openmode == OPJ_STREAM_WRITE) {
+			/* destroy the allocated buffer */
+			opj_free(cio->buffer);
+		}
+		/* destroy the cio */
+		opj_free(cio);
+	}
+}
+
+
+/* ----------------------------------------------------------------------- */
+
+/*
+ * Get position in byte stream.
+ */
+int OPJ_CALLCONV cio_tell(opj_cio_t *cio) {
+	return cio->bp - cio->start;
+}
+
+/*
+ * Set position in byte stream.
+ *
+ * pos : position, in number of bytes, from the beginning of the stream
+ */
+void OPJ_CALLCONV cio_seek(opj_cio_t *cio, int pos) {
+	cio->bp = cio->start + pos;
+}
+
+/*
+ * Number of bytes left before the end of the stream.
+ */
+int cio_numbytesleft(opj_cio_t *cio) {
+	return cio->end - cio->bp;
+}
+
+/*
+ * Get pointer to the current position in the stream.
+ */
+unsigned char *cio_getbp(opj_cio_t *cio) {
+	return cio->bp;
+}
+
+/*
+ * Write a byte.
+ */
+opj_bool cio_byteout(opj_cio_t *cio, unsigned char v) {
+	if (cio->bp >= cio->end) {
+		opj_event_msg(cio->cinfo, EVT_ERROR, "write error\n");
+		return OPJ_FALSE;
+	}
+	*cio->bp++ = v;
+	return OPJ_TRUE;
+}
+
+/*
+ * Read a byte.
+ */
+unsigned char cio_bytein(opj_cio_t *cio) {
+	if (cio->bp >= cio->end) {
+		opj_event_msg(cio->cinfo, EVT_ERROR, "read error: passed the end of the codestream (start = %d, current = %d, end = %d\n", cio->start, cio->bp, cio->end);
+		return 0;
+	}
+	return *cio->bp++;
+}
+
+/*
+ * Write some bytes.
+ *
+ * v : value to write
+ * n : number of bytes to write
+ */
+unsigned int cio_write(opj_cio_t *cio, unsigned int64 v, int n) {
+	int i;
+	for (i = n - 1; i >= 0; i--) {
+		if( !cio_byteout(cio, (unsigned char) ((v >> (i << 3)) & 0xff)) )
+			return 0;
+	}
+	return n;
+}
+
+/*
+ * Read some bytes.
+ *
+ * n : number of bytes to read
+ *
+ * return : value of the n bytes read
+ */
+unsigned int cio_read(opj_cio_t *cio, int n) {
+	int i;
+	unsigned int v;
+	v = 0;
+	for (i = n - 1; i >= 0; i--) {
+		v += cio_bytein(cio) << (i << 3);
+	}
+	return v;
+}
+
+/* 
+ * Skip some bytes.
+ *
+ * n : number of bytes to skip
+ */
+void cio_skip(opj_cio_t *cio, int n) {
+	cio->bp += n;
+}
+
+
+

src/add-ons/translators/icns/openjpeg/cio.h

@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __CIO_H
+#define __CIO_H
+
+#if defined(_MSC_VER) || defined(__BORLANDC__)
+#define int64 __int64
+#else
+#define int64 long long
+#endif
+
+/**
+@file cio.h
+@brief Implementation of a byte input-output process (CIO)
+
+The functions in CIO.C have for goal to realize a byte input / output process.
+*/
+
+/** @defgroup CIO CIO - byte input-output stream */
+/*@{*/
+
+/** @name Exported functions (see also openjpeg.h) */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+/**
+Number of bytes left before the end of the stream
+@param cio CIO handle
+@return Returns the number of bytes before the end of the stream
+*/
+int cio_numbytesleft(opj_cio_t *cio);
+/**
+Get pointer to the current position in the stream
+@param cio CIO handle
+@return Returns a pointer to the current position
+*/
+unsigned char *cio_getbp(opj_cio_t *cio);
+/**
+Write some bytes
+@param cio CIO handle
+@param v Value to write
+@param n Number of bytes to write
+@return Returns the number of bytes written or 0 if an error occured
+*/
+unsigned int cio_write(opj_cio_t *cio, unsigned int64 v, int n);
+/**
+Read some bytes
+@param cio CIO handle
+@param n Number of bytes to read
+@return Returns the value of the n bytes read
+*/
+unsigned int cio_read(opj_cio_t *cio, int n);
+/**
+Skip some bytes
+@param cio CIO handle
+@param n Number of bytes to skip
+*/
+void cio_skip(opj_cio_t *cio, int n);
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __CIO_H */
+

src/add-ons/translators/icns/openjpeg/dwt.c

@@ -0,0 +1,858 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * Copyright (c) 2007, Jonathan Ballard <[email protected]>
+ * Copyright (c) 2007, Callum Lerwick <[email protected]>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifdef __SSE__
+#include <xmmintrin.h>
+#endif
+
+#include "opj_includes.h"
+
+/** @defgroup DWT DWT - Implementation of a discrete wavelet transform */
+/*@{*/
+
+#define WS(i) v->mem[(i)*2]
+#define WD(i) v->mem[(1+(i)*2)]
+
+/** @name Local data structures */
+/*@{*/
+
+typedef struct dwt_local {
+	int* mem;
+	int dn;
+	int sn;
+	int cas;
+} dwt_t;
+
+typedef union {
+	float	f[4];
+} v4;
+
+typedef struct v4dwt_local {
+	v4*	wavelet ;
+	int		dn ;
+	int		sn ;
+	int		cas ;
+} v4dwt_t ;
+
+static const float dwt_alpha =  1.586134342f; /*  12994 */
+static const float dwt_beta  =  0.052980118f; /*    434 */
+static const float dwt_gamma = -0.882911075f; /*  -7233 */
+static const float dwt_delta = -0.443506852f; /*  -3633 */
+
+static const float K      = 1.230174105f; /*  10078 */
+/* FIXME: What is this constant? */
+static const float c13318 = 1.625732422f;
+
+/*@}*/
+
+/**
+Virtual function type for wavelet transform in 1-D 
+*/
+typedef void (*DWT1DFN)(dwt_t* v);
+
+/** @name Local static functions */
+/*@{*/
+
+/**
+Forward lazy transform (horizontal)
+*/
+static void dwt_deinterleave_h(int *a, int *b, int dn, int sn, int cas);
+/**
+Forward lazy transform (vertical)
+*/
+static void dwt_deinterleave_v(int *a, int *b, int dn, int sn, int x, int cas);
+/**
+Inverse lazy transform (horizontal)
+*/
+static void dwt_interleave_h(dwt_t* h, int *a);
+/**
+Inverse lazy transform (vertical)
+*/
+static void dwt_interleave_v(dwt_t* v, int *a, int x);
+/**
+Forward 5-3 wavelet transform in 1-D
+*/
+static void dwt_encode_1(int *a, int dn, int sn, int cas);
+/**
+Inverse 5-3 wavelet transform in 1-D
+*/
+static void dwt_decode_1(dwt_t *v);
+/**
+Forward 9-7 wavelet transform in 1-D
+*/
+static void dwt_encode_1_real(int *a, int dn, int sn, int cas);
+/**
+Explicit calculation of the Quantization Stepsizes 
+*/
+static void dwt_encode_stepsize(int stepsize, int numbps, opj_stepsize_t *bandno_stepsize);
+/**
+Inverse wavelet transform in 2-D.
+*/
+static void dwt_decode_tile(opj_tcd_tilecomp_t* tilec, int i, DWT1DFN fn);
+
+/*@}*/
+
+/*@}*/
+
+#define S(i) a[(i)*2]
+#define D(i) a[(1+(i)*2)]
+#define S_(i) ((i)<0?S(0):((i)>=sn?S(sn-1):S(i)))
+#define D_(i) ((i)<0?D(0):((i)>=dn?D(dn-1):D(i)))
+/* new */
+#define SS_(i) ((i)<0?S(0):((i)>=dn?S(dn-1):S(i)))
+#define DD_(i) ((i)<0?D(0):((i)>=sn?D(sn-1):D(i)))
+
+/* <summary>                                                              */
+/* This table contains the norms of the 5-3 wavelets for different bands. */
+/* </summary>                                                             */
+static const double dwt_norms[4][10] = {
+	{1.000, 1.500, 2.750, 5.375, 10.68, 21.34, 42.67, 85.33, 170.7, 341.3},
+	{1.038, 1.592, 2.919, 5.703, 11.33, 22.64, 45.25, 90.48, 180.9},
+	{1.038, 1.592, 2.919, 5.703, 11.33, 22.64, 45.25, 90.48, 180.9},
+	{.7186, .9218, 1.586, 3.043, 6.019, 12.01, 24.00, 47.97, 95.93}
+};
+
+/* <summary>                                                              */
+/* This table contains the norms of the 9-7 wavelets for different bands. */
+/* </summary>                                                             */
+static const double dwt_norms_real[4][10] = {
+	{1.000, 1.965, 4.177, 8.403, 16.90, 33.84, 67.69, 135.3, 270.6, 540.9},
+	{2.022, 3.989, 8.355, 17.04, 34.27, 68.63, 137.3, 274.6, 549.0},
+	{2.022, 3.989, 8.355, 17.04, 34.27, 68.63, 137.3, 274.6, 549.0},
+	{2.080, 3.865, 8.307, 17.18, 34.71, 69.59, 139.3, 278.6, 557.2}
+};
+
+/* 
+==========================================================
+   local functions
+==========================================================
+*/
+
+/* <summary>			                 */
+/* Forward lazy transform (horizontal).  */
+/* </summary>                            */ 
+static void dwt_deinterleave_h(int *a, int *b, int dn, int sn, int cas) {
+	int i;
+    for (i=0; i<sn; i++) b[i]=a[2*i+cas];
+    for (i=0; i<dn; i++) b[sn+i]=a[(2*i+1-cas)];
+}
+
+/* <summary>                             */  
+/* Forward lazy transform (vertical).    */
+/* </summary>                            */ 
+static void dwt_deinterleave_v(int *a, int *b, int dn, int sn, int x, int cas) {
+    int i;
+    for (i=0; i<sn; i++) b[i*x]=a[2*i+cas];
+    for (i=0; i<dn; i++) b[(sn+i)*x]=a[(2*i+1-cas)];
+}
+
+/* <summary>                             */
+/* Inverse lazy transform (horizontal).  */
+/* </summary>                            */
+static void dwt_interleave_h(dwt_t* h, int *a) {
+    int *ai = a;
+    int *bi = h->mem + h->cas;
+    int  i	= h->sn;
+    while( i-- ) {
+      *bi = *(ai++);
+	  bi += 2;
+    }
+    ai	= a + h->sn;
+    bi	= h->mem + 1 - h->cas;
+    i	= h->dn ;
+    while( i-- ) {
+      *bi = *(ai++);
+	  bi += 2;
+    }
+}
+
+/* <summary>                             */  
+/* Inverse lazy transform (vertical).    */
+/* </summary>                            */ 
+static void dwt_interleave_v(dwt_t* v, int *a, int x) {
+    int *ai = a;
+    int *bi = v->mem + v->cas;
+    int  i = v->sn;
+    while( i-- ) {
+      *bi = *ai;
+	  bi += 2;
+	  ai += x;
+    }
+    ai = a + (v->sn * x);
+    bi = v->mem + 1 - v->cas;
+    i = v->dn ;
+    while( i-- ) {
+      *bi = *ai;
+	  bi += 2;  
+	  ai += x;
+    }
+}
+
+
+/* <summary>                            */
+/* Forward 5-3 wavelet transform in 1-D. */
+/* </summary>                           */
+static void dwt_encode_1(int *a, int dn, int sn, int cas) {
+	int i;
+	
+	if (!cas) {
+		if ((dn > 0) || (sn > 1)) {	/* NEW :  CASE ONE ELEMENT */
+			for (i = 0; i < dn; i++) D(i) -= (S_(i) + S_(i + 1)) >> 1;
+			for (i = 0; i < sn; i++) S(i) += (D_(i - 1) + D_(i) + 2) >> 2;
+		}
+	} else {
+		if (!sn && dn == 1)		    /* NEW :  CASE ONE ELEMENT */
+			S(0) *= 2;
+		else {
+			for (i = 0; i < dn; i++) S(i) -= (DD_(i) + DD_(i - 1)) >> 1;
+			for (i = 0; i < sn; i++) D(i) += (SS_(i) + SS_(i + 1) + 2) >> 2;
+		}
+	}
+}
+
+/* <summary>                            */
+/* Inverse 5-3 wavelet transform in 1-D. */
+/* </summary>                           */ 
+static void dwt_decode_1_(int *a, int dn, int sn, int cas) {
+	int i;
+	
+	if (!cas) {
+		if ((dn > 0) || (sn > 1)) { /* NEW :  CASE ONE ELEMENT */
+			for (i = 0; i < sn; i++) S(i) -= (D_(i - 1) + D_(i) + 2) >> 2;
+			for (i = 0; i < dn; i++) D(i) += (S_(i) + S_(i + 1)) >> 1;
+		}
+	} else {
+		if (!sn  && dn == 1)          /* NEW :  CASE ONE ELEMENT */
+			S(0) /= 2;
+		else {
+			for (i = 0; i < sn; i++) D(i) -= (SS_(i) + SS_(i + 1) + 2) >> 2;
+			for (i = 0; i < dn; i++) S(i) += (DD_(i) + DD_(i - 1)) >> 1;
+		}
+	}
+}
+
+/* <summary>                            */
+/* Inverse 5-3 wavelet transform in 1-D. */
+/* </summary>                           */ 
+static void dwt_decode_1(dwt_t *v) {
+	dwt_decode_1_(v->mem, v->dn, v->sn, v->cas);
+}
+
+/* <summary>                             */
+/* Forward 9-7 wavelet transform in 1-D. */
+/* </summary>                            */
+static void dwt_encode_1_real(int *a, int dn, int sn, int cas) {
+	int i;
+	if (!cas) {
+		if ((dn > 0) || (sn > 1)) {	/* NEW :  CASE ONE ELEMENT */
+			for (i = 0; i < dn; i++)
+				D(i) -= fix_mul(S_(i) + S_(i + 1), 12993);
+			for (i = 0; i < sn; i++)
+				S(i) -= fix_mul(D_(i - 1) + D_(i), 434);
+			for (i = 0; i < dn; i++)
+				D(i) += fix_mul(S_(i) + S_(i + 1), 7233);
+			for (i = 0; i < sn; i++)
+				S(i) += fix_mul(D_(i - 1) + D_(i), 3633);
+			for (i = 0; i < dn; i++)
+				D(i) = fix_mul(D(i), 5038);	/*5038 */
+			for (i = 0; i < sn; i++)
+				S(i) = fix_mul(S(i), 6659);	/*6660 */
+		}
+	} else {
+		if ((sn > 0) || (dn > 1)) {	/* NEW :  CASE ONE ELEMENT */
+			for (i = 0; i < dn; i++)
+				S(i) -= fix_mul(DD_(i) + DD_(i - 1), 12993);
+			for (i = 0; i < sn; i++)
+				D(i) -= fix_mul(SS_(i) + SS_(i + 1), 434);
+			for (i = 0; i < dn; i++)
+				S(i) += fix_mul(DD_(i) + DD_(i - 1), 7233);
+			for (i = 0; i < sn; i++)
+				D(i) += fix_mul(SS_(i) + SS_(i + 1), 3633);
+			for (i = 0; i < dn; i++)
+				S(i) = fix_mul(S(i), 5038);	/*5038 */
+			for (i = 0; i < sn; i++)
+				D(i) = fix_mul(D(i), 6659);	/*6660 */
+		}
+	}
+}
+
+static void dwt_encode_stepsize(int stepsize, int numbps, opj_stepsize_t *bandno_stepsize) {
+	int p, n;
+	p = int_floorlog2(stepsize) - 13;
+	n = 11 - int_floorlog2(stepsize);
+	bandno_stepsize->mant = (n < 0 ? stepsize >> -n : stepsize << n) & 0x7ff;
+	bandno_stepsize->expn = numbps - p;
+}
+
+/* 
+==========================================================
+   DWT interface
+==========================================================
+*/
+
+/* <summary>                            */
+/* Forward 5-3 wavelet transform in 2-D. */
+/* </summary>                           */
+void dwt_encode(opj_tcd_tilecomp_t * tilec) {
+	int i, j, k;
+	int *a = NULL;
+	int *aj = NULL;
+	int *bj = NULL;
+	int w, l;
+	
+	w = tilec->x1-tilec->x0;
+	l = tilec->numresolutions-1;
+	a = tilec->data;
+	
+	for (i = 0; i < l; i++) {
+		int rw;			/* width of the resolution level computed                                                           */
+		int rh;			/* height of the resolution level computed                                                          */
+		int rw1;		/* width of the resolution level once lower than computed one                                       */
+		int rh1;		/* height of the resolution level once lower than computed one                                      */
+		int cas_col;	/* 0 = non inversion on horizontal filtering 1 = inversion between low-pass and high-pass filtering */
+		int cas_row;	/* 0 = non inversion on vertical filtering 1 = inversion between low-pass and high-pass filtering   */
+		int dn, sn;
+		
+		rw = tilec->resolutions[l - i].x1 - tilec->resolutions[l - i].x0;
+		rh = tilec->resolutions[l - i].y1 - tilec->resolutions[l - i].y0;
+		rw1= tilec->resolutions[l - i - 1].x1 - tilec->resolutions[l - i - 1].x0;
+		rh1= tilec->resolutions[l - i - 1].y1 - tilec->resolutions[l - i - 1].y0;
+		
+		cas_row = tilec->resolutions[l - i].x0 % 2;
+		cas_col = tilec->resolutions[l - i].y0 % 2;
+        
+		sn = rh1;
+		dn = rh - rh1;
+		bj = (int*)opj_malloc(rh * sizeof(int));
+		for (j = 0; j < rw; j++) {
+			aj = a + j;
+			for (k = 0; k < rh; k++)  bj[k] = aj[k*w];
+			dwt_encode_1(bj, dn, sn, cas_col);
+			dwt_deinterleave_v(bj, aj, dn, sn, w, cas_col);
+		}
+		opj_free(bj);
+		
+		sn = rw1;
+		dn = rw - rw1;
+		bj = (int*)opj_malloc(rw * sizeof(int));
+		for (j = 0; j < rh; j++) {
+			aj = a + j * w;
+			for (k = 0; k < rw; k++)  bj[k] = aj[k];
+			dwt_encode_1(bj, dn, sn, cas_row);
+			dwt_deinterleave_h(bj, aj, dn, sn, cas_row);
+		}
+		opj_free(bj);
+	}
+}
+
+
+/* <summary>                            */
+/* Inverse 5-3 wavelet transform in 2-D. */
+/* </summary>                           */
+void dwt_decode(opj_tcd_tilecomp_t* tilec, int numres) {
+	dwt_decode_tile(tilec, numres, &dwt_decode_1);
+}
+
+
+/* <summary>                          */
+/* Get gain of 5-3 wavelet transform. */
+/* </summary>                         */
+int dwt_getgain(int orient) {
+	if (orient == 0)
+		return 0;
+	if (orient == 1 || orient == 2)
+		return 1;
+	return 2;
+}
+
+/* <summary>                */
+/* Get norm of 5-3 wavelet. */
+/* </summary>               */
+double dwt_getnorm(int level, int orient) {
+	return dwt_norms[orient][level];
+}
+
+/* <summary>                             */
+/* Forward 9-7 wavelet transform in 2-D. */
+/* </summary>                            */
+
+void dwt_encode_real(opj_tcd_tilecomp_t * tilec) {
+	int i, j, k;
+	int *a = NULL;
+	int *aj = NULL;
+	int *bj = NULL;
+	int w, l;
+	
+	w = tilec->x1-tilec->x0;
+	l = tilec->numresolutions-1;
+	a = tilec->data;
+	
+	for (i = 0; i < l; i++) {
+		int rw;			/* width of the resolution level computed                                                     */
+		int rh;			/* height of the resolution level computed                                                    */
+		int rw1;		/* width of the resolution level once lower than computed one                                 */
+		int rh1;		/* height of the resolution level once lower than computed one                                */
+		int cas_col;	/* 0 = non inversion on horizontal filtering 1 = inversion between low-pass and high-pass filtering */
+		int cas_row;	/* 0 = non inversion on vertical filtering 1 = inversion between low-pass and high-pass filtering   */
+		int dn, sn;
+		
+		rw = tilec->resolutions[l - i].x1 - tilec->resolutions[l - i].x0;
+		rh = tilec->resolutions[l - i].y1 - tilec->resolutions[l - i].y0;
+		rw1= tilec->resolutions[l - i - 1].x1 - tilec->resolutions[l - i - 1].x0;
+		rh1= tilec->resolutions[l - i - 1].y1 - tilec->resolutions[l - i - 1].y0;
+		
+		cas_row = tilec->resolutions[l - i].x0 % 2;
+		cas_col = tilec->resolutions[l - i].y0 % 2;
+		
+		sn = rh1;
+		dn = rh - rh1;
+		bj = (int*)opj_malloc(rh * sizeof(int));
+		for (j = 0; j < rw; j++) {
+			aj = a + j;
+			for (k = 0; k < rh; k++)  bj[k] = aj[k*w];
+			dwt_encode_1_real(bj, dn, sn, cas_col);
+			dwt_deinterleave_v(bj, aj, dn, sn, w, cas_col);
+		}
+		opj_free(bj);
+		
+		sn = rw1;
+		dn = rw - rw1;
+		bj = (int*)opj_malloc(rw * sizeof(int));
+		for (j = 0; j < rh; j++) {
+			aj = a + j * w;
+			for (k = 0; k < rw; k++)  bj[k] = aj[k];
+			dwt_encode_1_real(bj, dn, sn, cas_row);
+			dwt_deinterleave_h(bj, aj, dn, sn, cas_row);
+		}
+		opj_free(bj);
+	}
+}
+
+
+/* <summary>                          */
+/* Get gain of 9-7 wavelet transform. */
+/* </summary>                         */
+int dwt_getgain_real(int orient) {
+	(void)orient;
+	return 0;
+}
+
+/* <summary>                */
+/* Get norm of 9-7 wavelet. */
+/* </summary>               */
+double dwt_getnorm_real(int level, int orient) {
+	return dwt_norms_real[orient][level];
+}
+
+void dwt_calc_explicit_stepsizes(opj_tccp_t * tccp, int prec) {
+	int numbands, bandno;
+	numbands = 3 * tccp->numresolutions - 2;
+	for (bandno = 0; bandno < numbands; bandno++) {
+		double stepsize;
+		int resno, level, orient, gain;
+
+		resno = (bandno == 0) ? 0 : ((bandno - 1) / 3 + 1);
+		orient = (bandno == 0) ? 0 : ((bandno - 1) % 3 + 1);
+		level = tccp->numresolutions - 1 - resno;
+		gain = (tccp->qmfbid == 0) ? 0 : ((orient == 0) ? 0 : (((orient == 1) || (orient == 2)) ? 1 : 2));
+		if (tccp->qntsty == J2K_CCP_QNTSTY_NOQNT) {
+			stepsize = 1.0;
+		} else {
+			double norm = dwt_norms_real[orient][level];
+			stepsize = (1 << (gain)) / norm;
+		}
+		dwt_encode_stepsize((int) floor(stepsize * 8192.0), prec + gain, &tccp->stepsizes[bandno]);
+	}
+}
+
+
+/* <summary>                             */
+/* Determine maximum computed resolution level for inverse wavelet transform */
+/* </summary>                            */
+static int dwt_decode_max_resolution(opj_tcd_resolution_t* restrict r, int i) {
+	int mr	= 1;
+	int w;
+	while( --i ) {
+		r++;
+		if( mr < ( w = r->x1 - r->x0 ) )
+			mr = w ;
+		if( mr < ( w = r->y1 - r->y0 ) )
+			mr = w ;
+	}
+	return mr ;
+}
+
+
+/* <summary>                            */
+/* Inverse wavelet transform in 2-D.     */
+/* </summary>                           */
+static void dwt_decode_tile(opj_tcd_tilecomp_t* tilec, int numres, DWT1DFN dwt_1D) {
+	dwt_t h;
+	dwt_t v;
+
+	opj_tcd_resolution_t* tr = tilec->resolutions;
+
+	int rw = tr->x1 - tr->x0;	/* width of the resolution level computed */
+	int rh = tr->y1 - tr->y0;	/* height of the resolution level computed */
+
+	int w = tilec->x1 - tilec->x0;
+
+	h.mem = (int*)opj_aligned_malloc(dwt_decode_max_resolution(tr, numres) * sizeof(int));
+	v.mem = h.mem;
+
+	while( --numres) {
+		int * restrict tiledp = tilec->data;
+		int j;
+
+		++tr;
+		h.sn = rw;
+		v.sn = rh;
+
+		rw = tr->x1 - tr->x0;
+		rh = tr->y1 - tr->y0;
+
+		h.dn = rw - h.sn;
+		h.cas = tr->x0 % 2;
+
+		for(j = 0; j < rh; ++j) {
+			dwt_interleave_h(&h, &tiledp[j*w]);
+			(dwt_1D)(&h);
+			memcpy(&tiledp[j*w], h.mem, rw * sizeof(int));
+		}
+
+		v.dn = rh - v.sn;
+		v.cas = tr->y0 % 2;
+
+		for(j = 0; j < rw; ++j){
+			int k;
+			dwt_interleave_v(&v, &tiledp[j], w);
+			(dwt_1D)(&v);
+			for(k = 0; k < rh; ++k) {
+				tiledp[k * w + j] = v.mem[k];
+			}
+		}
+	}
+	opj_aligned_free(h.mem);
+}
+
+static void v4dwt_interleave_h(v4dwt_t* restrict w, float* restrict a, int x, int size){
+	float* restrict bi = (float*) (w->wavelet + w->cas);
+	int count = w->sn;
+	int i, k;
+	for(k = 0; k < 2; ++k){
+		if (count + 3 * x < size && ((size_t) a & 0x0f) == 0 && ((size_t) bi & 0x0f) == 0 && (x & 0x0f) == 0) {
+			/* Fast code path */
+			for(i = 0; i < count; ++i){
+				int j = i;
+				bi[i*8    ] = a[j];
+				j += x;
+				bi[i*8 + 1] = a[j];
+				j += x;
+				bi[i*8 + 2] = a[j];
+				j += x;
+				bi[i*8 + 3] = a[j];
+			}
+		} else {
+			/* Slow code path */
+		for(i = 0; i < count; ++i){
+			int j = i;
+			bi[i*8    ] = a[j];
+			j += x;
+			if(j > size) continue;
+			bi[i*8 + 1] = a[j];
+			j += x;
+			if(j > size) continue;
+			bi[i*8 + 2] = a[j];
+			j += x;
+			if(j > size) continue;
+			bi[i*8 + 3] = a[j];
+		}
+		}
+		bi = (float*) (w->wavelet + 1 - w->cas);
+		a += w->sn;
+		size -= w->sn;
+		count = w->dn;
+	}
+}
+
+static void v4dwt_interleave_v(v4dwt_t* restrict v , float* restrict a , int x){
+	v4* restrict bi = v->wavelet + v->cas;
+	int i;
+	for(i = 0; i < v->sn; ++i){
+		memcpy(&bi[i*2], &a[i*x], 4 * sizeof(float));
+	}
+	a += v->sn * x;
+	bi = v->wavelet + 1 - v->cas;
+	for(i = 0; i < v->dn; ++i){
+		memcpy(&bi[i*2], &a[i*x], 4 * sizeof(float));
+	}
+}
+
+#ifdef __SSE__
+
+static void v4dwt_decode_step1_sse(v4* w, int count, const __m128 c){
+	__m128* restrict vw = (__m128*) w;
+	int i;
+	/* 4x unrolled loop */
+	for(i = 0; i < count >> 2; ++i){
+		*vw = _mm_mul_ps(*vw, c);
+		vw += 2;
+		*vw = _mm_mul_ps(*vw, c);
+		vw += 2;
+		*vw = _mm_mul_ps(*vw, c);
+		vw += 2;
+		*vw = _mm_mul_ps(*vw, c);
+		vw += 2;
+	}
+	count &= 3;
+	for(i = 0; i < count; ++i){
+		*vw = _mm_mul_ps(*vw, c);
+		vw += 2;
+	}
+}
+
+static void v4dwt_decode_step2_sse(v4* l, v4* w, int k, int m, __m128 c){
+	__m128* restrict vl = (__m128*) l;
+	__m128* restrict vw = (__m128*) w;
+	int i;
+	__m128 tmp1, tmp2, tmp3;
+	tmp1 = vl[0];
+	for(i = 0; i < m; ++i){
+		tmp2 = vw[-1];
+		tmp3 = vw[ 0];
+		vw[-1] = _mm_add_ps(tmp2, _mm_mul_ps(_mm_add_ps(tmp1, tmp3), c));
+		tmp1 = tmp3;
+		vw += 2;
+	}
+	vl = vw - 2;
+	if(m >= k){
+		return;
+	}
+	c = _mm_add_ps(c, c);
+	c = _mm_mul_ps(c, vl[0]);
+	for(; m < k; ++m){
+		__m128 tmp = vw[-1];
+		vw[-1] = _mm_add_ps(tmp, c);
+		vw += 2;
+	}
+}
+
+#else
+
+static void v4dwt_decode_step1(v4* w, int count, const float c){
+	float* restrict fw = (float*) w;
+	int i;
+	for(i = 0; i < count; ++i){
+		float tmp1 = fw[i*8    ];
+		float tmp2 = fw[i*8 + 1];
+		float tmp3 = fw[i*8 + 2];
+		float tmp4 = fw[i*8 + 3];
+		fw[i*8    ] = tmp1 * c;
+		fw[i*8 + 1] = tmp2 * c;
+		fw[i*8 + 2] = tmp3 * c;
+		fw[i*8 + 3] = tmp4 * c;
+	}
+}
+
+static void v4dwt_decode_step2(v4* l, v4* w, int k, int m, float c){
+	float* restrict fl = (float*) l;
+	float* restrict fw = (float*) w;
+	int i;
+	for(i = 0; i < m; ++i){
+		float tmp1_1 = fl[0];
+		float tmp1_2 = fl[1];
+		float tmp1_3 = fl[2];
+		float tmp1_4 = fl[3];
+		float tmp2_1 = fw[-4];
+		float tmp2_2 = fw[-3];
+		float tmp2_3 = fw[-2];
+		float tmp2_4 = fw[-1];
+		float tmp3_1 = fw[0];
+		float tmp3_2 = fw[1];
+		float tmp3_3 = fw[2];
+		float tmp3_4 = fw[3];
+		fw[-4] = tmp2_1 + ((tmp1_1 + tmp3_1) * c);
+		fw[-3] = tmp2_2 + ((tmp1_2 + tmp3_2) * c);
+		fw[-2] = tmp2_3 + ((tmp1_3 + tmp3_3) * c);
+		fw[-1] = tmp2_4 + ((tmp1_4 + tmp3_4) * c);
+		fl = fw;
+		fw += 8;
+	}
+	if(m < k){
+		float c1;
+		float c2;
+		float c3;
+		float c4;
+		c += c;
+		c1 = fl[0] * c;
+		c2 = fl[1] * c;
+		c3 = fl[2] * c;
+		c4 = fl[3] * c;
+		for(; m < k; ++m){
+			float tmp1 = fw[-4];
+			float tmp2 = fw[-3];
+			float tmp3 = fw[-2];
+			float tmp4 = fw[-1];
+			fw[-4] = tmp1 + c1;
+			fw[-3] = tmp2 + c2;
+			fw[-2] = tmp3 + c3;
+			fw[-1] = tmp4 + c4;
+			fw += 8;
+		}
+	}
+}
+
+#endif
+
+/* <summary>                             */
+/* Inverse 9-7 wavelet transform in 1-D. */
+/* </summary>                            */
+static void v4dwt_decode(v4dwt_t* restrict dwt){
+	int a, b;
+	if(dwt->cas == 0) {
+		if(!((dwt->dn > 0) || (dwt->sn > 1))){
+			return;
+		}
+		a = 0;
+		b = 1;
+	}else{
+		if(!((dwt->sn > 0) || (dwt->dn > 1))) {
+			return;
+		}
+		a = 1;
+		b = 0;
+	}
+#ifdef __SSE__
+	v4dwt_decode_step1_sse(dwt->wavelet+a, dwt->sn, _mm_set1_ps(K));
+	v4dwt_decode_step1_sse(dwt->wavelet+b, dwt->dn, _mm_set1_ps(c13318));
+	v4dwt_decode_step2_sse(dwt->wavelet+b, dwt->wavelet+a+1, dwt->sn, int_min(dwt->sn, dwt->dn-a), _mm_set1_ps(dwt_delta));
+	v4dwt_decode_step2_sse(dwt->wavelet+a, dwt->wavelet+b+1, dwt->dn, int_min(dwt->dn, dwt->sn-b), _mm_set1_ps(dwt_gamma));
+	v4dwt_decode_step2_sse(dwt->wavelet+b, dwt->wavelet+a+1, dwt->sn, int_min(dwt->sn, dwt->dn-a), _mm_set1_ps(dwt_beta));
+	v4dwt_decode_step2_sse(dwt->wavelet+a, dwt->wavelet+b+1, dwt->dn, int_min(dwt->dn, dwt->sn-b), _mm_set1_ps(dwt_alpha));
+#else
+	v4dwt_decode_step1(dwt->wavelet+a, dwt->sn, K);
+	v4dwt_decode_step1(dwt->wavelet+b, dwt->dn, c13318);
+	v4dwt_decode_step2(dwt->wavelet+b, dwt->wavelet+a+1, dwt->sn, int_min(dwt->sn, dwt->dn-a), dwt_delta);
+	v4dwt_decode_step2(dwt->wavelet+a, dwt->wavelet+b+1, dwt->dn, int_min(dwt->dn, dwt->sn-b), dwt_gamma);
+	v4dwt_decode_step2(dwt->wavelet+b, dwt->wavelet+a+1, dwt->sn, int_min(dwt->sn, dwt->dn-a), dwt_beta);
+	v4dwt_decode_step2(dwt->wavelet+a, dwt->wavelet+b+1, dwt->dn, int_min(dwt->dn, dwt->sn-b), dwt_alpha);
+#endif
+}
+
+/* <summary>                             */
+/* Inverse 9-7 wavelet transform in 2-D. */
+/* </summary>                            */
+void dwt_decode_real(opj_tcd_tilecomp_t* restrict tilec, int numres){
+	v4dwt_t h;
+	v4dwt_t v;
+
+	opj_tcd_resolution_t* res = tilec->resolutions;
+
+	int rw = res->x1 - res->x0;	/* width of the resolution level computed */
+	int rh = res->y1 - res->y0;	/* height of the resolution level computed */
+
+	int w = tilec->x1 - tilec->x0;
+
+	h.wavelet = (v4*) opj_aligned_malloc((dwt_decode_max_resolution(res, numres)+5) * sizeof(v4));
+	v.wavelet = h.wavelet;
+
+	while( --numres) {
+		float * restrict aj = (float*) tilec->data;
+		int bufsize = (tilec->x1 - tilec->x0) * (tilec->y1 - tilec->y0);
+		int j;
+
+		h.sn = rw;
+		v.sn = rh;
+
+		++res;
+
+		rw = res->x1 - res->x0;	/* width of the resolution level computed */
+		rh = res->y1 - res->y0;	/* height of the resolution level computed */
+
+		h.dn = rw - h.sn;
+		h.cas = res->x0 % 2;
+
+		for(j = rh; j > 3; j -= 4){
+			int k;
+			v4dwt_interleave_h(&h, aj, w, bufsize);
+			v4dwt_decode(&h);
+				for(k = rw; --k >= 0;){
+					aj[k    ] = h.wavelet[k].f[0];
+					aj[k+w  ] = h.wavelet[k].f[1];
+					aj[k+w*2] = h.wavelet[k].f[2];
+					aj[k+w*3] = h.wavelet[k].f[3];
+				}
+			aj += w*4;
+			bufsize -= w*4;
+		}
+		if (rh & 0x03) {
+				int k;
+			j = rh & 0x03;
+			v4dwt_interleave_h(&h, aj, w, bufsize);
+			v4dwt_decode(&h);
+				for(k = rw; --k >= 0;){
+					switch(j) {
+						case 3: aj[k+w*2] = h.wavelet[k].f[2];
+						case 2: aj[k+w  ] = h.wavelet[k].f[1];
+						case 1: aj[k    ] = h.wavelet[k].f[0];
+					}
+				}
+			}
+
+		v.dn = rh - v.sn;
+		v.cas = res->y0 % 2;
+
+		aj = (float*) tilec->data;
+		for(j = rw; j > 3; j -= 4){
+			int k;
+			v4dwt_interleave_v(&v, aj, w);
+			v4dwt_decode(&v);
+				for(k = 0; k < rh; ++k){
+					memcpy(&aj[k*w], &v.wavelet[k], 4 * sizeof(float));
+				}
+			aj += 4;
+		}
+		if (rw & 0x03){
+				int k;
+			j = rw & 0x03;
+			v4dwt_interleave_v(&v, aj, w);
+			v4dwt_decode(&v);
+				for(k = 0; k < rh; ++k){
+					memcpy(&aj[k*w], &v.wavelet[k], j * sizeof(float));
+				}
+			}
+	}
+
+	opj_aligned_free(h.wavelet);
+}
+

src/add-ons/translators/icns/openjpeg/dwt.h

@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __DWT_H
+#define __DWT_H
+/**
+@file dwt.h
+@brief Implementation of a discrete wavelet transform (DWT)
+
+The functions in DWT.C have for goal to realize forward and inverse discret wavelet
+transform with filter 5-3 (reversible) and filter 9-7 (irreversible). The functions in
+DWT.C are used by some function in TCD.C.
+*/
+
+/** @defgroup DWT DWT - Implementation of a discrete wavelet transform */
+/*@{*/
+
+
+/** @name Exported functions */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+/**
+Forward 5-3 wavelet tranform in 2-D. 
+Apply a reversible DWT transform to a component of an image.
+@param tilec Tile component information (current tile)
+*/
+void dwt_encode(opj_tcd_tilecomp_t * tilec);
+/**
+Inverse 5-3 wavelet tranform in 2-D.
+Apply a reversible inverse DWT transform to a component of an image.
+@param tilec Tile component information (current tile)
+@param numres Number of resolution levels to decode
+*/
+void dwt_decode(opj_tcd_tilecomp_t* tilec, int numres);
+/**
+Get the gain of a subband for the reversible 5-3 DWT.
+@param orient Number that identifies the subband (0->LL, 1->HL, 2->LH, 3->HH)
+@return Returns 0 if orient = 0, returns 1 if orient = 1 or 2, returns 2 otherwise
+*/
+int dwt_getgain(int orient);
+/**
+Get the norm of a wavelet function of a subband at a specified level for the reversible 5-3 DWT.
+@param level Level of the wavelet function
+@param orient Band of the wavelet function
+@return Returns the norm of the wavelet function
+*/
+double dwt_getnorm(int level, int orient);
+/**
+Forward 9-7 wavelet transform in 2-D. 
+Apply an irreversible DWT transform to a component of an image.
+@param tilec Tile component information (current tile)
+*/
+void dwt_encode_real(opj_tcd_tilecomp_t * tilec);
+/**
+Inverse 9-7 wavelet transform in 2-D. 
+Apply an irreversible inverse DWT transform to a component of an image.
+@param tilec Tile component information (current tile)
+@param numres Number of resolution levels to decode
+*/
+void dwt_decode_real(opj_tcd_tilecomp_t* tilec, int numres);
+/**
+Get the gain of a subband for the irreversible 9-7 DWT.
+@param orient Number that identifies the subband (0->LL, 1->HL, 2->LH, 3->HH)
+@return Returns the gain of the 9-7 wavelet transform
+*/
+int dwt_getgain_real(int orient);
+/**
+Get the norm of a wavelet function of a subband at a specified level for the irreversible 9-7 DWT
+@param level Level of the wavelet function
+@param orient Band of the wavelet function
+@return Returns the norm of the 9-7 wavelet
+*/
+double dwt_getnorm_real(int level, int orient);
+/**
+Explicit calculation of the Quantization Stepsizes 
+@param tccp Tile-component coding parameters
+@param prec Precint analyzed
+*/
+void dwt_calc_explicit_stepsizes(opj_tccp_t * tccp, int prec);
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __DWT_H */

src/add-ons/translators/icns/openjpeg/event.c

@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "opj_includes.h"
+
+/* ==========================================================
+     Utility functions
+   ==========================================================*/
+
+#ifdef OPJ_CODE_NOT_USED
+#ifndef _WIN32
+static char*
+i2a(unsigned i, char *a, unsigned r) {
+	if (i/r > 0) a = i2a(i/r,a,r);
+	*a = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[i%r];
+	return a+1;
+}
+
+/** 
+ Transforms integer i into an ascii string and stores the result in a; 
+ string is encoded in the base indicated by r.
+ @param i Number to be converted
+ @param a String result
+ @param r Base of value; must be in the range 2 - 36
+ @return Returns a
+*/
+static char *
+_itoa(int i, char *a, int r) {
+	r = ((r < 2) || (r > 36)) ? 10 : r;
+	if(i < 0) {
+		*a = '-';
+		*i2a(-i, a+1, r) = 0;
+	}
+	else *i2a(i, a, r) = 0;
+	return a;
+}
+
+#endif /* !_WIN32 */
+#endif
+/* ----------------------------------------------------------------------- */
+
+opj_event_mgr_t* OPJ_CALLCONV opj_set_event_mgr(opj_common_ptr cinfo, opj_event_mgr_t *event_mgr, void *context) {
+	if(cinfo) {
+		opj_event_mgr_t *previous = cinfo->event_mgr;
+		cinfo->event_mgr = event_mgr;
+		cinfo->client_data = context;
+		return previous;
+	}
+
+	return NULL;
+}
+
+opj_bool opj_event_msg(opj_common_ptr cinfo, int event_type, const char *fmt, ...) {
+#define MSG_SIZE 512 /* 512 bytes should be more than enough for a short message */
+	opj_msg_callback msg_handler = NULL;
+
+	opj_event_mgr_t *event_mgr = cinfo->event_mgr;
+	if(event_mgr != NULL) {
+		switch(event_type) {
+			case EVT_ERROR:
+				msg_handler = event_mgr->error_handler;
+				break;
+			case EVT_WARNING:
+				msg_handler = event_mgr->warning_handler;
+				break;
+			case EVT_INFO:
+				msg_handler = event_mgr->info_handler;
+				break;
+			default:
+				break;
+		}
+		if(msg_handler == NULL) {
+			return OPJ_FALSE;
+		}
+	} else {
+		return OPJ_FALSE;
+	}
+
+	if ((fmt != NULL) && (event_mgr != NULL)) {
+		va_list arg;
+		int str_length/*, i, j*/; /* UniPG */
+		char message[MSG_SIZE];
+		/* initialize the optional parameter list */
+		va_start(arg, fmt);
+		/* parse the format string and put the result in 'message' */
+		str_length = vsnprintf(message, MSG_SIZE, fmt, arg); /* UniPG */
+		/* deinitialize the optional parameter list */
+		va_end(arg);
+
+		/* output the message to the user program */
+    if( str_length > -1 && str_length < MSG_SIZE )
+      msg_handler(message, cinfo->client_data);
+    else return OPJ_FALSE;
+	}
+
+	return OPJ_TRUE;
+}
+

src/add-ons/translators/icns/openjpeg/event.h

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __EVENT_H
+#define __EVENT_H
+/**
+@file event.h
+@brief Implementation of a event callback system
+
+The functions in EVENT.C have for goal to send output messages (errors, warnings, debug) to the user.
+*/
+
+#define EVT_ERROR	1	/**< Error event type */
+#define EVT_WARNING	2	/**< Warning event type */
+#define EVT_INFO	4	/**< Debug event type */
+
+/** @defgroup EVENT EVENT - Implementation of a event callback system */
+/*@{*/
+
+/** @name Exported functions (see also openjpeg.h) */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+/**
+Write formatted data to a string and send the string to a user callback. 
+@param cinfo Codec context info
+@param event_type Event type or callback to use to send the message
+@param fmt Format-control string (plus optionnal arguments)
+@return Returns true if successful, returns false otherwise
+*/
+opj_bool opj_event_msg(opj_common_ptr cinfo, int event_type, const char *fmt, ...);
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __EVENT_H */

src/add-ons/translators/icns/openjpeg/fix.h

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __FIX_H
+#define __FIX_H
+
+#if defined(_MSC_VER) || defined(__BORLANDC__)
+#define int64 __int64
+#else
+#define int64 long long
+#endif
+
+/**
+@file fix.h
+@brief Implementation of operations of specific multiplication (FIX)
+
+The functions in FIX.H have for goal to realize specific multiplication.
+*/
+
+/** @defgroup FIX FIX - Implementation of operations of specific multiplication */
+/*@{*/
+
+/**
+Multiply two fixed-precision rational numbers.
+@param a
+@param b
+@return Returns a * b
+*/
+static INLINE int fix_mul(int a, int b) {
+    int64 temp = (int64) a * (int64) b ;
+    temp += temp & 4096;
+    return (int) (temp >> 13) ;
+}
+
+/*@}*/
+
+#endif /* __FIX_H */

src/add-ons/translators/icns/openjpeg/image.c

@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "opj_includes.h"
+
+opj_image_t* opj_image_create0(void) {
+	opj_image_t *image = (opj_image_t*)opj_calloc(1, sizeof(opj_image_t));
+	return image;
+}
+
+opj_image_t* OPJ_CALLCONV opj_image_create(int numcmpts, opj_image_cmptparm_t *cmptparms, OPJ_COLOR_SPACE clrspc) {
+	int compno;
+	opj_image_t *image = NULL;
+
+	image = (opj_image_t*) opj_calloc(1, sizeof(opj_image_t));
+	if(image) {
+		image->color_space = clrspc;
+		image->numcomps = numcmpts;
+		/* allocate memory for the per-component information */
+		image->comps = (opj_image_comp_t*)opj_malloc(image->numcomps * sizeof(opj_image_comp_t));
+		if(!image->comps) {
+			fprintf(stderr,"Unable to allocate memory for image.\n");
+			opj_image_destroy(image);
+			return NULL;
+		}
+		/* create the individual image components */
+		for(compno = 0; compno < numcmpts; compno++) {
+			opj_image_comp_t *comp = &image->comps[compno];
+			comp->dx = cmptparms[compno].dx;
+			comp->dy = cmptparms[compno].dy;
+			comp->w = cmptparms[compno].w;
+			comp->h = cmptparms[compno].h;
+			comp->x0 = cmptparms[compno].x0;
+			comp->y0 = cmptparms[compno].y0;
+			comp->prec = cmptparms[compno].prec;
+			comp->bpp = cmptparms[compno].bpp;
+			comp->sgnd = cmptparms[compno].sgnd;
+			comp->data = (int*) opj_calloc(comp->w * comp->h, sizeof(int));
+			if(!comp->data) {
+				fprintf(stderr,"Unable to allocate memory for image.\n");
+				opj_image_destroy(image);
+				return NULL;
+			}
+		}
+	}
+
+	return image;
+}
+
+void OPJ_CALLCONV opj_image_destroy(opj_image_t *image) {
+	int i;
+	if(image) {
+		if(image->comps) {
+			/* image components */
+			for(i = 0; i < image->numcomps; i++) {
+				opj_image_comp_t *image_comp = &image->comps[i];
+				if(image_comp->data) {
+					opj_free(image_comp->data);
+				}
+			}
+			opj_free(image->comps);
+		}
+		opj_free(image);
+	}
+}
+

src/add-ons/translators/icns/openjpeg/indexbox_manager.h

@@ -0,0 +1,118 @@
+/*
+ * $Id: indexbox_manager.h 897 2011-08-28 21:43:57Z [email protected] $
+ *
+ * Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2011, Professor Benoit Macq
+ * Copyright (c) 2003-2004, Yannick Verschueren
+ * Copyright (c) 2010-2011, Kaori Hagihara
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*! \file
+ *  \brief Modification of jpip.c from 2KAN indexer
+ */
+
+#ifndef  INDEXBOX_MANAGER_H_
+# define INDEXBOX_MANAGER_H_
+
+#include "openjpeg.h"
+#include "j2k.h" /* needed to use jp2.h */
+#include "jp2.h"
+
+#define JPIP_CIDX 0x63696478   /* Codestream index                */
+#define JPIP_CPTR 0x63707472   /* Codestream Finder Box           */
+#define JPIP_MANF 0x6d616e66   /* Manifest Box                    */
+#define JPIP_FAIX 0x66616978   /* Fragment array Index box        */
+#define JPIP_MHIX 0x6d686978   /* Main Header Index Table         */
+#define JPIP_TPIX 0x74706978   /* Tile-part Index Table box       */
+#define JPIP_THIX 0x74686978   /* Tile header Index Table box     */
+#define JPIP_PPIX 0x70706978   /* Precinct Packet Index Table box */
+#define JPIP_PHIX 0x70686978   /* Packet Header index Table       */
+#define JPIP_FIDX 0x66696478   /* File Index                      */
+#define JPIP_FPTR 0x66707472   /* File Finder                     */
+#define JPIP_PRXY 0x70727879   /* Proxy boxes                     */
+#define JPIP_IPTR 0x69707472   /* Index finder box                */
+#define JPIP_PHLD 0x70686c64   /* Place holder                    */
+
+
+/* 
+ * Write tile-part Index table box (superbox)
+ *
+ * @param[in] coff      offset of j2k codestream
+ * @param[in] cstr_info codestream information
+ * @param[in] j2klen    length of j2k codestream
+ * @param[in] cio       file output handle
+ * @return              length of tpix box
+ */
+int write_tpix( int coff, opj_codestream_info_t cstr_info, int j2klen, opj_cio_t *cio);
+
+
+/* 
+ * Write tile header index table box (superbox)
+ *
+ * @param[in] coff      offset of j2k codestream
+ * @param[in] cstr_info codestream information pointer
+ * @param[in] cio       file output handle
+ * @return              length of thix box
+ */
+int write_thix( int coff, opj_codestream_info_t cstr_info, opj_cio_t *cio);
+
+
+/* 
+ * Write precinct packet index table box (superbox)
+ *
+ * @param[in] coff      offset of j2k codestream
+ * @param[in] cstr_info codestream information
+ * @param[in] EPHused   true if EPH option used
+ * @param[in] j2klen    length of j2k codestream
+ * @param[in] cio       file output handle
+ * @return              length of ppix box
+ */
+int write_ppix( int coff, opj_codestream_info_t cstr_info, opj_bool EPHused, int j2klen, opj_cio_t *cio);
+
+
+/* 
+ * Write packet header index table box (superbox)
+ *
+ * @param[in] coff      offset of j2k codestream
+ * @param[in] cstr_info codestream information
+ * @param[in] EPHused   true if EPH option used
+ * @param[in] j2klen    length of j2k codestream
+ * @param[in] cio       file output handle
+ * @return              length of ppix box
+ */
+int write_phix( int coff, opj_codestream_info_t cstr_info, opj_bool EPHused, int j2klen, opj_cio_t *cio);
+
+/* 
+ * Wriet manifest box (box)
+ *
+ * @param[in] second number to be visited
+ * @param[in] v      number of boxes
+ * @param[in] box    box to be manifested
+ * @param[in] cio    file output handle
+ */
+void write_manf(int second, int v, opj_jp2_box_t *box, opj_cio_t *cio);
+
+
+#endif      /* !INDEXBOX_MANAGER_H_ */

src/add-ons/translators/icns/openjpeg/int.h

@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __INT_H
+#define __INT_H
+/**
+@file int.h
+@brief Implementation of operations on integers (INT)
+
+The functions in INT.H have for goal to realize operations on integers.
+*/
+
+/** @defgroup INT INT - Implementation of operations on integers */
+/*@{*/
+
+/** @name Exported functions (see also openjpeg.h) */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+/**
+Get the minimum of two integers
+@return Returns a if a < b else b
+*/
+static INLINE int int_min(int a, int b) {
+	return a < b ? a : b;
+}
+/**
+Get the maximum of two integers
+@return Returns a if a > b else b
+*/
+static INLINE int int_max(int a, int b) {
+	return (a > b) ? a : b;
+}
+/**
+Clamp an integer inside an interval
+@return
+<ul>
+<li>Returns a if (min < a < max)
+<li>Returns max if (a > max)
+<li>Returns min if (a < min) 
+</ul>
+*/
+static INLINE int int_clamp(int a, int min, int max) {
+	if (a < min)
+		return min;
+	if (a > max)
+		return max;
+	return a;
+}
+/**
+@return Get absolute value of integer
+*/
+static INLINE int int_abs(int a) {
+	return a < 0 ? -a : a;
+}
+/**
+Divide an integer and round upwards
+@return Returns a divided by b
+*/
+static INLINE int int_ceildiv(int a, int b) {
+	return (a + b - 1) / b;
+}
+/**
+Divide an integer by a power of 2 and round upwards
+@return Returns a divided by 2^b
+*/
+static INLINE int int_ceildivpow2(int a, int b) {
+	return (a + (1 << b) - 1) >> b;
+}
+/**
+Divide an integer by a power of 2 and round downwards
+@return Returns a divided by 2^b
+*/
+static INLINE int int_floordivpow2(int a, int b) {
+	return a >> b;
+}
+/**
+Get logarithm of an integer and round downwards
+@return Returns log2(a)
+*/
+static INLINE int int_floorlog2(int a) {
+	int l;
+	for (l = 0; a > 1; l++) {
+		a >>= 1;
+	}
+	return l;
+}
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif

src/add-ons/translators/icns/openjpeg/j2k.h

@@ -0,0 +1,446 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * Copyright (c) 2006-2007, Parvatha Elangovan
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __J2K_H
+#define __J2K_H
+/**
+@file j2k.h
+@brief The JPEG-2000 Codestream Reader/Writer (J2K)
+
+The functions in J2K.C have for goal to read/write the several parts of the codestream: markers and data.
+*/
+
+/** @defgroup J2K J2K - JPEG-2000 codestream reader/writer */
+/*@{*/
+
+#define J2K_CP_CSTY_PRT 0x01
+#define J2K_CP_CSTY_SOP 0x02
+#define J2K_CP_CSTY_EPH 0x04
+#define J2K_CCP_CSTY_PRT 0x01
+#define J2K_CCP_CBLKSTY_LAZY 0x01     /**< Selective arithmetic coding bypass */
+#define J2K_CCP_CBLKSTY_RESET 0x02    /**< Reset context probabilities on coding pass boundaries */
+#define J2K_CCP_CBLKSTY_TERMALL 0x04  /**< Termination on each coding pass */
+#define J2K_CCP_CBLKSTY_VSC 0x08      /**< Vertically stripe causal context */
+#define J2K_CCP_CBLKSTY_PTERM 0x10    /**< Predictable termination */
+#define J2K_CCP_CBLKSTY_SEGSYM 0x20   /**< Segmentation symbols are used */
+#define J2K_CCP_QNTSTY_NOQNT 0
+#define J2K_CCP_QNTSTY_SIQNT 1
+#define J2K_CCP_QNTSTY_SEQNT 2
+
+/* ----------------------------------------------------------------------- */
+
+#define J2K_MS_SOC 0xff4f	/**< SOC marker value */
+#define J2K_MS_SOT 0xff90	/**< SOT marker value */
+#define J2K_MS_SOD 0xff93	/**< SOD marker value */
+#define J2K_MS_EOC 0xffd9	/**< EOC marker value */
+#define J2K_MS_SIZ 0xff51	/**< SIZ marker value */
+#define J2K_MS_COD 0xff52	/**< COD marker value */
+#define J2K_MS_COC 0xff53	/**< COC marker value */
+#define J2K_MS_RGN 0xff5e	/**< RGN marker value */
+#define J2K_MS_QCD 0xff5c	/**< QCD marker value */
+#define J2K_MS_QCC 0xff5d	/**< QCC marker value */
+#define J2K_MS_POC 0xff5f	/**< POC marker value */
+#define J2K_MS_TLM 0xff55	/**< TLM marker value */
+#define J2K_MS_PLM 0xff57	/**< PLM marker value */
+#define J2K_MS_PLT 0xff58	/**< PLT marker value */
+#define J2K_MS_PPM 0xff60	/**< PPM marker value */
+#define J2K_MS_PPT 0xff61	/**< PPT marker value */
+#define J2K_MS_SOP 0xff91	/**< SOP marker value */
+#define J2K_MS_EPH 0xff92	/**< EPH marker value */
+#define J2K_MS_CRG 0xff63	/**< CRG marker value */
+#define J2K_MS_COM 0xff64	/**< COM marker value */
+/* UniPG>> */
+#ifdef USE_JPWL
+#define J2K_MS_EPC 0xff68	/**< EPC marker value (Part 11: JPEG 2000 for Wireless) */
+#define J2K_MS_EPB 0xff66	/**< EPB marker value (Part 11: JPEG 2000 for Wireless) */ 
+#define J2K_MS_ESD 0xff67	/**< ESD marker value (Part 11: JPEG 2000 for Wireless) */ 
+#define J2K_MS_RED 0xff69	/**< RED marker value (Part 11: JPEG 2000 for Wireless) */
+#endif /* USE_JPWL */
+#ifdef USE_JPSEC
+#define J2K_MS_SEC 0xff65    /**< SEC marker value (Part 8: Secure JPEG 2000) */
+#define J2K_MS_INSEC 0xff94  /**< INSEC marker value (Part 8: Secure JPEG 2000) */
+#endif /* USE_JPSEC */
+/* <<UniPG */
+
+
+/* ----------------------------------------------------------------------- */
+
+/**
+Values that specify the status of the decoding process when decoding the main header. 
+These values may be combined with a | operator. 
+*/
+typedef enum J2K_STATUS {
+	J2K_STATE_MHSOC  = 0x0001, /**< a SOC marker is expected */
+	J2K_STATE_MHSIZ  = 0x0002, /**< a SIZ marker is expected */
+	J2K_STATE_MH     = 0x0004, /**< the decoding process is in the main header */
+	J2K_STATE_TPHSOT = 0x0008, /**< the decoding process is in a tile part header and expects a SOT marker */
+	J2K_STATE_TPH    = 0x0010, /**< the decoding process is in a tile part header */
+	J2K_STATE_MT     = 0x0020, /**< the EOC marker has just been read */
+	J2K_STATE_NEOC   = 0x0040, /**< the decoding process must not expect a EOC marker because the codestream is truncated */
+	J2K_STATE_ERR    = 0x0080  /**< the decoding process has encountered an error */
+} J2K_STATUS;
+
+/* ----------------------------------------------------------------------- */
+
+/** 
+T2 encoding mode 
+*/
+typedef enum T2_MODE {
+	THRESH_CALC = 0,	/** Function called in Rate allocation process*/
+	FINAL_PASS = 1		/** Function called in Tier 2 process*/
+}J2K_T2_MODE;
+
+/**
+Quantization stepsize
+*/
+typedef struct opj_stepsize {
+	/** exponent */
+	int expn;
+	/** mantissa */
+	int mant;
+} opj_stepsize_t;
+
+/**
+Tile-component coding parameters
+*/
+typedef struct opj_tccp {
+	/** coding style */
+	int csty;
+	/** number of resolutions */
+	int numresolutions;
+	/** code-blocks width */
+	int cblkw;
+	/** code-blocks height */
+	int cblkh;
+	/** code-block coding style */
+	int cblksty;
+	/** discrete wavelet transform identifier */
+	int qmfbid;
+	/** quantisation style */
+	int qntsty;
+	/** stepsizes used for quantization */
+	opj_stepsize_t stepsizes[J2K_MAXBANDS];
+	/** number of guard bits */
+	int numgbits;
+	/** Region Of Interest shift */
+	int roishift;
+	/** precinct width */
+	int prcw[J2K_MAXRLVLS];
+	/** precinct height */
+	int prch[J2K_MAXRLVLS];	
+} opj_tccp_t;
+
+/**
+Tile coding parameters : 
+this structure is used to store coding/decoding parameters common to all
+tiles (information like COD, COC in main header)
+*/
+typedef struct opj_tcp {
+	/** 1 : first part-tile of a tile */
+	int first;
+	/** coding style */
+	int csty;
+	/** progression order */
+	OPJ_PROG_ORDER prg;
+	/** number of layers */
+	int numlayers;
+	/** multi-component transform identifier */
+	int mct;
+	/** rates of layers */
+	float rates[100];
+	/** number of progression order changes */
+	int numpocs;
+	/** indicates if a POC marker has been used O:NO, 1:YES */
+	int POC;
+	/** progression order changes */
+	opj_poc_t pocs[32];
+	/** packet header store there for futur use in t2_decode_packet */
+	unsigned char *ppt_data;
+	/** pointer remaining on the first byte of the first header if ppt is used */
+	unsigned char *ppt_data_first;
+	/** If ppt == 1 --> there was a PPT marker for the present tile */
+	int ppt;
+	/** used in case of multiple marker PPT (number of info already stored) */
+	int ppt_store;
+	/** ppmbug1 */
+	int ppt_len;
+	/** add fixed_quality */
+	float distoratio[100];
+	/** tile-component coding parameters */
+	opj_tccp_t *tccps;
+} opj_tcp_t;
+
+/**
+Coding parameters
+*/
+typedef struct opj_cp {
+	/** Digital cinema profile*/
+	OPJ_CINEMA_MODE cinema;
+	/** Maximum rate for each component. If == 0, component size limitation is not considered */
+	int max_comp_size;
+	/** Size of the image in bits*/
+	int img_size;
+	/** Rsiz*/
+	OPJ_RSIZ_CAPABILITIES rsiz;
+	/** Enabling Tile part generation*/
+	char tp_on;
+	/** Flag determining tile part generation*/
+	char tp_flag;
+	/** Position of tile part flag in progression order*/
+	int tp_pos;
+	/** allocation by rate/distortion */
+	int disto_alloc;
+	/** allocation by fixed layer */
+	int fixed_alloc;
+	/** add fixed_quality */
+	int fixed_quality;
+	/** if != 0, then original dimension divided by 2^(reduce); if == 0 or not used, image is decoded to the full resolution */
+	int reduce;
+	/** if != 0, then only the first "layer" layers are decoded; if == 0 or not used, all the quality layers are decoded */
+	int layer;
+	/** if == NO_LIMITATION, decode entire codestream; if == LIMIT_TO_MAIN_HEADER then only decode the main header */
+	OPJ_LIMIT_DECODING limit_decoding;
+	/** XTOsiz */
+	int tx0;
+	/** YTOsiz */
+	int ty0;
+	/** XTsiz */
+	int tdx;
+	/** YTsiz */
+	int tdy;
+	/** comment for coding */
+	char *comment;
+	/** number of tiles in width */
+	int tw;
+	/** number of tiles in heigth */
+	int th;
+	/** ID number of the tiles present in the codestream */
+	int *tileno;
+	/** size of the vector tileno */
+	int tileno_size;
+	/** packet header store there for futur use in t2_decode_packet */
+	unsigned char *ppm_data;
+	/** pointer remaining on the first byte of the first header if ppm is used */
+	unsigned char *ppm_data_first;
+	/** if ppm == 1 --> there was a PPM marker for the present tile */
+	int ppm;
+	/** use in case of multiple marker PPM (number of info already store) */
+	int ppm_store;
+	/** use in case of multiple marker PPM (case on non-finished previous info) */
+	int ppm_previous;
+	/** ppmbug1 */
+	int ppm_len;
+	/** tile coding parameters */
+	opj_tcp_t *tcps;
+	/** fixed layer */
+	int *matrice;
+/* UniPG>> */
+#ifdef USE_JPWL
+	/** enables writing of EPC in MH, thus activating JPWL */
+	opj_bool epc_on;
+	/** enables writing of EPB, in case of activated JPWL */
+	opj_bool epb_on;
+	/** enables writing of ESD, in case of activated JPWL */
+	opj_bool esd_on;
+	/** enables writing of informative techniques of ESD, in case of activated JPWL */
+	opj_bool info_on;
+	/** enables writing of RED, in case of activated JPWL */
+	opj_bool red_on;
+	/** error protection method for MH (0,1,16,32,37-128) */
+	int hprot_MH;
+	/** tile number of header protection specification (>=0) */
+	int hprot_TPH_tileno[JPWL_MAX_NO_TILESPECS];
+	/** error protection methods for TPHs (0,1,16,32,37-128) */
+	int hprot_TPH[JPWL_MAX_NO_TILESPECS];
+	/** tile number of packet protection specification (>=0) */
+	int pprot_tileno[JPWL_MAX_NO_PACKSPECS];
+	/** packet number of packet protection specification (>=0) */
+	int pprot_packno[JPWL_MAX_NO_PACKSPECS];
+	/** error protection methods for packets (0,1,16,32,37-128) */
+	int pprot[JPWL_MAX_NO_PACKSPECS];
+	/** enables writing of ESD, (0/2/4 bytes) */
+	int sens_size;
+	/** sensitivity addressing size (0=auto/2/4 bytes) */
+	int sens_addr;
+	/** sensitivity range (0-3) */
+	int sens_range;
+	/** sensitivity method for MH (-1,0-7) */
+	int sens_MH;
+	/** tile number of sensitivity specification (>=0) */
+	int sens_TPH_tileno[JPWL_MAX_NO_TILESPECS];
+	/** sensitivity methods for TPHs (-1,0-7) */
+	int sens_TPH[JPWL_MAX_NO_TILESPECS];
+	/** enables JPWL correction at the decoder */
+	opj_bool correct;
+	/** expected number of components at the decoder */
+	int exp_comps;
+	/** maximum number of tiles at the decoder */
+	int max_tiles;
+#endif /* USE_JPWL */
+/* <<UniPG */
+} opj_cp_t;
+
+/**
+JPEG-2000 codestream reader/writer
+*/
+typedef struct opj_j2k {
+	/** codec context */
+	opj_common_ptr cinfo;
+
+	/** locate in which part of the codestream the decoder is (main header, tile header, end) */
+	int state;
+	/** number of the tile curently concern by coding/decoding */
+	int curtileno;
+	/** Tile part number*/
+	int tp_num;
+	/** Tilepart number currently coding*/
+	int cur_tp_num;
+	/** Total number of tileparts of the current tile*/
+	int *cur_totnum_tp;
+	/**
+	locate the start position of the TLM marker  
+	after encoding the tilepart, a jump (in j2k_write_sod) is done to the TLM marker to store the value of its length. 
+	*/
+	int tlm_start;
+	/** Total num of tile parts in whole image = num tiles* num tileparts in each tile*/
+	/** used in TLMmarker*/
+	int totnum_tp;	
+	/** 
+	locate the position of the end of the tile in the codestream, 
+	used to detect a truncated codestream (in j2k_read_sod)
+	*/
+	unsigned char *eot;
+	/**
+	locate the start position of the SOT marker of the current coded tile:  
+	after encoding the tile, a jump (in j2k_write_sod) is done to the SOT marker to store the value of its length. 
+	*/
+	int sot_start;
+	int sod_start;
+	/**
+	as the J2K-file is written in several parts during encoding, 
+	it enables to make the right correction in position return by cio_tell
+	*/
+	int pos_correction;
+	/** array used to store the data of each tile */
+	unsigned char **tile_data;
+	/** array used to store the length of each tile */
+	int *tile_len;
+	/** 
+	decompression only : 
+	store decoding parameters common to all tiles (information like COD, COC in main header)
+	*/
+	opj_tcp_t *default_tcp;
+	/** pointer to the encoded / decoded image */
+	opj_image_t *image;
+	/** pointer to the coding parameters */
+	opj_cp_t *cp;
+	/** helper used to write the index file */
+	opj_codestream_info_t *cstr_info;
+	/** pointer to the byte i/o stream */
+	opj_cio_t *cio;
+} opj_j2k_t;
+
+/** @name Exported functions */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+/**
+Creates a J2K decompression structure
+@param cinfo Codec context info
+@return Returns a handle to a J2K decompressor if successful, returns NULL otherwise
+*/
+opj_j2k_t* j2k_create_decompress(opj_common_ptr cinfo);
+/**
+Destroy a J2K decompressor handle
+@param j2k J2K decompressor handle to destroy
+*/
+void j2k_destroy_decompress(opj_j2k_t *j2k);
+/**
+Setup the decoder decoding parameters using user parameters.
+Decoding parameters are returned in j2k->cp. 
+@param j2k J2K decompressor handle
+@param parameters decompression parameters
+*/
+void j2k_setup_decoder(opj_j2k_t *j2k, opj_dparameters_t *parameters);
+/**
+Decode an image from a JPEG-2000 codestream
+@param j2k J2K decompressor handle
+@param cio Input buffer stream
+@param cstr_info Codestream information structure if required, NULL otherwise
+@return Returns a decoded image if successful, returns NULL otherwise
+*/
+opj_image_t* j2k_decode(opj_j2k_t *j2k, opj_cio_t *cio, opj_codestream_info_t *cstr_info);
+/**
+Decode an image form a JPT-stream (JPEG 2000, JPIP)
+@param j2k J2K decompressor handle
+@param cio Input buffer stream
+@param cstr_info Codestream information structure if required, NULL otherwise
+@return Returns a decoded image if successful, returns NULL otherwise
+*/
+opj_image_t* j2k_decode_jpt_stream(opj_j2k_t *j2k, opj_cio_t *cio, opj_codestream_info_t *cstr_info);
+/**
+Creates a J2K compression structure
+@param cinfo Codec context info
+@return Returns a handle to a J2K compressor if successful, returns NULL otherwise
+*/
+opj_j2k_t* j2k_create_compress(opj_common_ptr cinfo);
+/**
+Destroy a J2K compressor handle
+@param j2k J2K compressor handle to destroy
+*/
+void j2k_destroy_compress(opj_j2k_t *j2k);
+/**
+Setup the encoder parameters using the current image and using user parameters. 
+Coding parameters are returned in j2k->cp. 
+@param j2k J2K compressor handle
+@param parameters compression parameters
+@param image input filled image
+*/
+void j2k_setup_encoder(opj_j2k_t *j2k, opj_cparameters_t *parameters, opj_image_t *image);
+/**
+Converts an enum type progression order to string type
+*/
+char *j2k_convert_progression_order(OPJ_PROG_ORDER prg_order);
+/**
+Encode an image into a JPEG-2000 codestream
+@param j2k J2K compressor handle
+@param cio Output buffer stream
+@param image Image to encode
+@param cstr_info Codestream information structure if required, NULL otherwise
+@return Returns true if successful, returns false otherwise
+*/
+opj_bool j2k_encode(opj_j2k_t *j2k, opj_cio_t *cio, opj_image_t *image, opj_codestream_info_t *cstr_info);
+
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __J2K_H */

src/add-ons/translators/icns/openjpeg/j2k_lib.c

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <sys/times.h>
+#endif /* _WIN32 */
+#include "opj_includes.h"
+
+double opj_clock(void) {
+#ifdef _WIN32
+	/* _WIN32: use QueryPerformance (very accurate) */
+    LARGE_INTEGER freq , t ;
+    /* freq is the clock speed of the CPU */
+    QueryPerformanceFrequency(&freq) ;
+	/* cout << "freq = " << ((double) freq.QuadPart) << endl; */
+    /* t is the high resolution performance counter (see MSDN) */
+    QueryPerformanceCounter ( & t ) ;
+    return ( t.QuadPart /(double) freq.QuadPart ) ;
+#else
+	/* Unix or Linux: use resource usage */
+    struct rusage t;
+    double procTime;
+    /* (1) Get the rusage data structure at this moment (man getrusage) */
+    getrusage(0,&t);
+    /* (2) What is the elapsed time ? - CPU time = User time + System time */
+	/* (2a) Get the seconds */
+    procTime = t.ru_utime.tv_sec + t.ru_stime.tv_sec;
+    /* (2b) More precisely! Get the microseconds part ! */
+    return ( procTime + (t.ru_utime.tv_usec + t.ru_stime.tv_usec) * 1e-6 ) ;
+#endif
+}
+

src/add-ons/translators/icns/openjpeg/j2k_lib.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __J2K_LIB_H
+#define __J2K_LIB_H
+/**
+@file j2k_lib.h
+@brief Internal functions
+
+The functions in J2K_LIB.C are internal utilities mainly used for timing.
+*/
+
+/** @defgroup MISC MISC - Miscellaneous internal functions */
+/*@{*/
+
+/** @name Exported functions */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+
+/**
+Difference in successive opj_clock() calls tells you the elapsed time
+@return Returns time in seconds
+*/
+double opj_clock(void);
+
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __J2K_LIB_H */
+

src/add-ons/translators/icns/openjpeg/jp2.h

@@ -0,0 +1,234 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __JP2_H
+#define __JP2_H
+/**
+@file jp2.h
+@brief The JPEG-2000 file format Reader/Writer (JP2)
+
+*/
+
+/** @defgroup JP2 JP2 - JPEG-2000 file format reader/writer */
+/*@{*/
+
+#define JPIP_JPIP 0x6a706970
+
+#define JP2_JP   0x6a502020		/**< JPEG 2000 signature box */
+#define JP2_FTYP 0x66747970		/**< File type box */
+#define JP2_JP2H 0x6a703268		/**< JP2 header box */
+#define JP2_IHDR 0x69686472		/**< Image header box */
+#define JP2_COLR 0x636f6c72		/**< Colour specification box */
+#define JP2_JP2C 0x6a703263		/**< Contiguous codestream box */
+#define JP2_URL  0x75726c20		/**< URL box */
+#define JP2_DTBL 0x6474626c		/**< Data Reference box */
+#define JP2_BPCC 0x62706363		/**< Bits per component box */
+#define JP2_JP2  0x6a703220		/**< File type fields */
+#define JP2_PCLR 0x70636c72		/**< Palette box */
+#define JP2_CMAP 0x636d6170		/**< Component Mapping box */
+#define JP2_CDEF 0x63646566		/**< Channel Definition box */
+
+/* ----------------------------------------------------------------------- */
+/** 
+Channel description: channel index, type, assocation
+*/
+typedef struct opj_jp2_cdef_info
+{
+    unsigned short cn, typ, asoc;
+} opj_jp2_cdef_info_t;
+
+/** 
+Channel descriptions and number of descriptions
+*/
+typedef struct opj_jp2_cdef
+{
+    opj_jp2_cdef_info_t *info;
+    unsigned short n;
+} opj_jp2_cdef_t;
+
+/** 
+Component mappings: channel index, mapping type, palette index
+*/
+typedef struct opj_jp2_cmap_comp
+{
+    unsigned short cmp;
+    unsigned char mtyp, pcol;
+} opj_jp2_cmap_comp_t;
+
+/** 
+Palette data: table entries, palette columns
+*/
+typedef struct opj_jp2_pclr
+{
+    unsigned int *entries;
+    unsigned char *channel_sign;
+    unsigned char *channel_size;
+    opj_jp2_cmap_comp_t *cmap;
+    unsigned short nr_entries, nr_channels;
+} opj_jp2_pclr_t;
+
+/** 
+Collector for ICC profile, palette, component mapping, channel description 
+*/
+typedef struct opj_jp2_color
+{
+    unsigned char *icc_profile_buf;
+    int icc_profile_len;
+
+    opj_jp2_cdef_t *jp2_cdef;
+    opj_jp2_pclr_t *jp2_pclr;
+    unsigned char jp2_has_colr;
+} opj_jp2_color_t;
+
+/** 
+JP2 component
+*/
+typedef struct opj_jp2_comps {
+  int depth;		  
+  int sgnd;		   
+  int bpcc;
+} opj_jp2_comps_t;
+
+/**
+JPEG-2000 file format reader/writer
+*/
+typedef struct opj_jp2 {
+	/** codec context */
+	opj_common_ptr cinfo;
+	/** handle to the J2K codec  */
+	opj_j2k_t *j2k;
+	unsigned int w;
+	unsigned int h;
+	unsigned int numcomps;
+	unsigned int bpc;
+	unsigned int C;
+	unsigned int UnkC;
+	unsigned int IPR;
+	unsigned int meth;
+	unsigned int approx;
+	unsigned int enumcs;
+	unsigned int precedence;
+	unsigned int brand;
+	unsigned int minversion;
+	unsigned int numcl;
+	unsigned int *cl;
+	opj_jp2_comps_t *comps;
+	unsigned int j2k_codestream_offset;
+	unsigned int j2k_codestream_length;
+	opj_bool jpip_on;
+	opj_bool ignore_pclr_cmap_cdef;
+} opj_jp2_t;
+
+/**
+JP2 Box
+*/
+typedef struct opj_jp2_box {
+  int length;
+  int type;
+  int init_pos;
+} opj_jp2_box_t;
+
+/** @name Exported functions */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+/**
+Write the JP2H box - JP2 Header box (used in MJ2)
+@param jp2 JP2 handle
+@param cio Output buffer stream
+*/
+void jp2_write_jp2h(opj_jp2_t *jp2, opj_cio_t *cio);
+/**
+Read the JP2H box - JP2 Header box (used in MJ2)
+@param jp2 JP2 handle
+@param cio Input buffer stream
+@param ext Collector for profile, cdef and pclr data
+@return Returns true if successful, returns false otherwise
+*/
+opj_bool jp2_read_jp2h(opj_jp2_t *jp2, opj_cio_t *cio, opj_jp2_color_t *color);
+/**
+Creates a JP2 decompression structure
+@param cinfo Codec context info
+@return Returns a handle to a JP2 decompressor if successful, returns NULL otherwise
+*/
+opj_jp2_t* jp2_create_decompress(opj_common_ptr cinfo);
+/**
+Destroy a JP2 decompressor handle
+@param jp2 JP2 decompressor handle to destroy
+*/
+void jp2_destroy_decompress(opj_jp2_t *jp2);
+/**
+Setup the decoder decoding parameters using user parameters.
+Decoding parameters are returned in jp2->j2k->cp. 
+@param jp2 JP2 decompressor handle
+@param parameters decompression parameters
+*/
+void jp2_setup_decoder(opj_jp2_t *jp2, opj_dparameters_t *parameters);
+/**
+Decode an image from a JPEG-2000 file stream
+@param jp2 JP2 decompressor handle
+@param cio Input buffer stream
+@param cstr_info Codestream information structure if required, NULL otherwise
+@return Returns a decoded image if successful, returns NULL otherwise
+*/
+opj_image_t* opj_jp2_decode(opj_jp2_t *jp2, opj_cio_t *cio, opj_codestream_info_t *cstr_info);
+/**
+Creates a JP2 compression structure
+@param cinfo Codec context info
+@return Returns a handle to a JP2 compressor if successful, returns NULL otherwise
+*/
+opj_jp2_t* jp2_create_compress(opj_common_ptr cinfo);
+/**
+Destroy a JP2 compressor handle
+@param jp2 JP2 compressor handle to destroy
+*/
+void jp2_destroy_compress(opj_jp2_t *jp2);
+/**
+Setup the encoder parameters using the current image and using user parameters. 
+Coding parameters are returned in jp2->j2k->cp. 
+@param jp2 JP2 compressor handle
+@param parameters compression parameters
+@param image input filled image
+*/
+void jp2_setup_encoder(opj_jp2_t *jp2, opj_cparameters_t *parameters, opj_image_t *image);
+/**
+Encode an image into a JPEG-2000 file stream
+@param jp2 JP2 compressor handle
+@param cio Output buffer stream
+@param image Image to encode
+@param cstr_info Codestream information structure if required, NULL otherwise
+@return Returns true if successful, returns false otherwise
+*/
+opj_bool opj_jp2_encode(opj_jp2_t *jp2, opj_cio_t *cio, opj_image_t *image, opj_codestream_info_t *cstr_info);
+
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __JP2_H */
+

src/add-ons/translators/icns/openjpeg/jpt.c

@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "opj_includes.h"
+
+/*
+ * Read the information contains in VBAS [JPP/JPT stream message header]
+ * Store information (7 bits) in value
+ *
+ */
+unsigned int jpt_read_VBAS_info(opj_cio_t *cio, unsigned int value) {
+	unsigned char elmt;
+
+	elmt = cio_read(cio, 1);
+	while ((elmt >> 7) == 1) {
+		value = (value << 7);
+		value |= (elmt & 0x7f);
+		elmt = cio_read(cio, 1);
+	}
+	value = (value << 7);
+	value |= (elmt & 0x7f);
+
+	return value;
+}
+
+/*
+ * Initialize the value of the message header structure 
+ *
+ */
+void jpt_init_msg_header(opj_jpt_msg_header_t * header) {
+	header->Id = 0;		/* In-class Identifier    */
+	header->last_byte = 0;	/* Last byte information  */
+	header->Class_Id = 0;		/* Class Identifier       */
+	header->CSn_Id = 0;		/* CSn : index identifier */
+	header->Msg_offset = 0;	/* Message offset         */
+	header->Msg_length = 0;	/* Message length         */
+	header->Layer_nb = 0;		/* Auxiliary for JPP case */
+}
+
+/*
+ * Re-initialize the value of the message header structure
+ *
+ * Only parameters always present in message header
+ *
+ */
+void jpt_reinit_msg_header(opj_jpt_msg_header_t * header) {
+	header->Id = 0;		/* In-class Identifier    */
+	header->last_byte = 0;	/* Last byte information  */
+	header->Msg_offset = 0;	/* Message offset         */
+	header->Msg_length = 0;	/* Message length         */
+}
+
+/*
+ * Read the message header for a JPP/JPT - stream
+ *
+ */
+void jpt_read_msg_header(opj_common_ptr cinfo, opj_cio_t *cio, opj_jpt_msg_header_t *header) {
+	unsigned char elmt, Class = 0, CSn = 0;
+	jpt_reinit_msg_header(header);
+
+	/* ------------- */
+	/* VBAS : Bin-ID */
+	/* ------------- */
+	elmt = cio_read(cio, 1);
+
+	/* See for Class and CSn */
+	switch ((elmt >> 5) & 0x03) {
+		case 0:
+			opj_event_msg(cinfo, EVT_ERROR, "Forbidden value encounter in message header !!\n");
+			break;
+		case 1:
+			Class = 0;
+			CSn = 0;
+			break;
+		case 2:
+			Class = 1;
+			CSn = 0;
+			break;
+		case 3:
+			Class = 1;
+			CSn = 1;
+			break;
+		default:
+			break;
+	}
+
+	/* see information on bits 'c' [p 10 : A.2.1 general, ISO/IEC FCD 15444-9] */
+	if (((elmt >> 4) & 0x01) == 1)
+		header->last_byte = 1;
+
+	/* In-class identifier */
+	header->Id |= (elmt & 0x0f);
+	if ((elmt >> 7) == 1)
+		header->Id = jpt_read_VBAS_info(cio, header->Id);
+
+	/* ------------ */
+	/* VBAS : Class */
+	/* ------------ */
+	if (Class == 1) {
+		header->Class_Id = 0;
+		header->Class_Id = jpt_read_VBAS_info(cio, header->Class_Id);
+	}
+
+	/* ---------- */
+	/* VBAS : CSn */
+	/* ---------- */
+	if (CSn == 1) {
+		header->CSn_Id = 0;
+		header->CSn_Id = jpt_read_VBAS_info(cio, header->CSn_Id);
+	}
+
+	/* ----------------- */
+	/* VBAS : Msg_offset */
+	/* ----------------- */
+	header->Msg_offset = jpt_read_VBAS_info(cio, header->Msg_offset);
+
+	/* ----------------- */
+	/* VBAS : Msg_length */
+	/* ----------------- */
+	header->Msg_length = jpt_read_VBAS_info(cio, header->Msg_length);
+
+	/* ---------- */
+	/* VBAS : Aux */
+	/* ---------- */
+	if ((header->Class_Id & 0x01) == 1) {
+		header->Layer_nb = 0;
+		header->Layer_nb = jpt_read_VBAS_info(cio, header->Layer_nb);
+	}
+}

src/add-ons/translators/icns/openjpeg/jpt.h

@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __JPT_H
+#define __JPT_H
+/**
+@file jpt.h
+@brief JPT-stream reader (JPEG 2000, JPIP)
+
+JPT-stream functions are implemented in J2K.C. 
+*/
+
+/**
+Message Header JPT stream structure
+*/
+typedef struct opj_jpt_msg_header {
+	/** In-class Identifier */
+	unsigned int Id;
+	/** Last byte information */
+	unsigned int last_byte;	
+	/** Class Identifier */
+	unsigned int Class_Id;	
+	/** CSn : index identifier */
+	unsigned int CSn_Id;
+	/** Message offset */
+	unsigned int Msg_offset;
+	/** Message length */
+	unsigned int Msg_length;
+	/** Auxiliary for JPP case */
+	unsigned int Layer_nb;
+} opj_jpt_msg_header_t;
+
+/* ----------------------------------------------------------------------- */
+
+/**
+Initialize the value of the message header structure 
+@param header Message header structure
+*/
+void jpt_init_msg_header(opj_jpt_msg_header_t * header);
+
+/**
+Read the message header for a JPP/JPT - stream
+@param cinfo Codec context info
+@param cio CIO handle
+@param header Message header structure
+*/
+void jpt_read_msg_header(opj_common_ptr cinfo, opj_cio_t *cio, opj_jpt_msg_header_t *header);
+
+#endif

src/add-ons/translators/icns/openjpeg/mct.c

@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifdef __SSE__
+#include <xmmintrin.h>
+#endif
+
+#include "opj_includes.h"
+
+/* <summary> */
+/* This table contains the norms of the basis function of the reversible MCT. */
+/* </summary> */
+static const double mct_norms[3] = { 1.732, .8292, .8292 };
+
+/* <summary> */
+/* This table contains the norms of the basis function of the irreversible MCT. */
+/* </summary> */
+static const double mct_norms_real[3] = { 1.732, 1.805, 1.573 };
+
+/* <summary> */
+/* Foward reversible MCT. */
+/* </summary> */
+void mct_encode(
+		int* restrict c0,
+		int* restrict c1,
+		int* restrict c2,
+		int n)
+{
+	int i;
+	for(i = 0; i < n; ++i) {
+		int r = c0[i];
+		int g = c1[i];
+		int b = c2[i];
+		int y = (r + (g * 2) + b) >> 2;
+		int u = b - g;
+		int v = r - g;
+		c0[i] = y;
+		c1[i] = u;
+		c2[i] = v;
+	}
+}
+
+/* <summary> */
+/* Inverse reversible MCT. */
+/* </summary> */
+void mct_decode(
+		int* restrict c0,
+		int* restrict c1, 
+		int* restrict c2, 
+		int n)
+{
+	int i;
+	for (i = 0; i < n; ++i) {
+		int y = c0[i];
+		int u = c1[i];
+		int v = c2[i];
+		int g = y - ((u + v) >> 2);
+		int r = v + g;
+		int b = u + g;
+		c0[i] = r;
+		c1[i] = g;
+		c2[i] = b;
+	}
+}
+
+/* <summary> */
+/* Get norm of basis function of reversible MCT. */
+/* </summary> */
+double mct_getnorm(int compno) {
+	return mct_norms[compno];
+}
+
+/* <summary> */
+/* Foward irreversible MCT. */
+/* </summary> */
+void mct_encode_real(
+		int* restrict c0,
+		int* restrict c1,
+		int* restrict c2,
+		int n)
+{
+	int i;
+	for(i = 0; i < n; ++i) {
+		int r = c0[i];
+		int g = c1[i];
+		int b = c2[i];
+		int y =  fix_mul(r, 2449) + fix_mul(g, 4809) + fix_mul(b, 934);
+		int u = -fix_mul(r, 1382) - fix_mul(g, 2714) + fix_mul(b, 4096);
+		int v =  fix_mul(r, 4096) - fix_mul(g, 3430) - fix_mul(b, 666);
+		c0[i] = y;
+		c1[i] = u;
+		c2[i] = v;
+	}
+}
+
+/* <summary> */
+/* Inverse irreversible MCT. */
+/* </summary> */
+void mct_decode_real(
+		float* restrict c0,
+		float* restrict c1,
+		float* restrict c2,
+		int n)
+{
+	int i;
+#ifdef __SSE__
+	__m128 vrv, vgu, vgv, vbu;
+	vrv = _mm_set1_ps(1.402f);
+	vgu = _mm_set1_ps(0.34413f);
+	vgv = _mm_set1_ps(0.71414f);
+	vbu = _mm_set1_ps(1.772f);
+	for (i = 0; i < (n >> 3); ++i) {
+		__m128 vy, vu, vv;
+		__m128 vr, vg, vb;
+
+		vy = _mm_load_ps(c0);
+		vu = _mm_load_ps(c1);
+		vv = _mm_load_ps(c2);
+		vr = _mm_add_ps(vy, _mm_mul_ps(vv, vrv));
+		vg = _mm_sub_ps(_mm_sub_ps(vy, _mm_mul_ps(vu, vgu)), _mm_mul_ps(vv, vgv));
+		vb = _mm_add_ps(vy, _mm_mul_ps(vu, vbu));
+		_mm_store_ps(c0, vr);
+		_mm_store_ps(c1, vg);
+		_mm_store_ps(c2, vb);
+		c0 += 4;
+		c1 += 4;
+		c2 += 4;
+
+		vy = _mm_load_ps(c0);
+		vu = _mm_load_ps(c1);
+		vv = _mm_load_ps(c2);
+		vr = _mm_add_ps(vy, _mm_mul_ps(vv, vrv));
+		vg = _mm_sub_ps(_mm_sub_ps(vy, _mm_mul_ps(vu, vgu)), _mm_mul_ps(vv, vgv));
+		vb = _mm_add_ps(vy, _mm_mul_ps(vu, vbu));
+		_mm_store_ps(c0, vr);
+		_mm_store_ps(c1, vg);
+		_mm_store_ps(c2, vb);
+		c0 += 4;
+		c1 += 4;
+		c2 += 4;
+	}
+	n &= 7;
+#endif
+	for(i = 0; i < n; ++i) {
+		float y = c0[i];
+		float u = c1[i];
+		float v = c2[i];
+		float r = y + (v * 1.402f);
+		float g = y - (u * 0.34413f) - (v * (0.71414f));
+		float b = y + (u * 1.772f);
+		c0[i] = r;
+		c1[i] = g;
+		c2[i] = b;
+	}
+}
+
+/* <summary> */
+/* Get norm of basis function of irreversible MCT. */
+/* </summary> */
+double mct_getnorm_real(int compno) {
+	return mct_norms_real[compno];
+}

src/add-ons/translators/icns/openjpeg/mct.h

@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __MCT_H
+#define __MCT_H
+/**
+@file mct.h
+@brief Implementation of a multi-component transforms (MCT)
+
+The functions in MCT.C have for goal to realize reversible and irreversible multicomponent
+transform. The functions in MCT.C are used by some function in TCD.C.
+*/
+
+/** @defgroup MCT MCT - Implementation of a multi-component transform */
+/*@{*/
+
+/** @name Exported functions */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+/**
+Apply a reversible multi-component transform to an image
+@param c0 Samples for red component
+@param c1 Samples for green component
+@param c2 Samples blue component
+@param n Number of samples for each component
+*/
+void mct_encode(int *c0, int *c1, int *c2, int n);
+/**
+Apply a reversible multi-component inverse transform to an image
+@param c0 Samples for luminance component
+@param c1 Samples for red chrominance component
+@param c2 Samples for blue chrominance component
+@param n Number of samples for each component
+*/
+void mct_decode(int *c0, int *c1, int *c2, int n);
+/**
+Get norm of the basis function used for the reversible multi-component transform
+@param compno Number of the component (0->Y, 1->U, 2->V)
+@return 
+*/
+double mct_getnorm(int compno);
+
+/**
+Apply an irreversible multi-component transform to an image
+@param c0 Samples for red component
+@param c1 Samples for green component
+@param c2 Samples blue component
+@param n Number of samples for each component
+*/
+void mct_encode_real(int *c0, int *c1, int *c2, int n);
+/**
+Apply an irreversible multi-component inverse transform to an image
+@param c0 Samples for luminance component
+@param c1 Samples for red chrominance component
+@param c2 Samples for blue chrominance component
+@param n Number of samples for each component
+*/
+void mct_decode_real(float* c0, float* c1, float* c2, int n);
+/**
+Get norm of the basis function used for the irreversible multi-component transform
+@param compno Number of the component (0->Y, 1->U, 2->V)
+@return 
+*/
+double mct_getnorm_real(int compno);
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __MCT_H */

src/add-ons/translators/icns/openjpeg/mqc.c

@@ -0,0 +1,592 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "opj_includes.h"
+
+/** @defgroup MQC MQC - Implementation of an MQ-Coder */
+/*@{*/
+
+/** @name Local static functions */
+/*@{*/
+
+/**
+Output a byte, doing bit-stuffing if necessary.
+After a 0xff byte, the next byte must be smaller than 0x90.
+@param mqc MQC handle
+*/
+static void mqc_byteout(opj_mqc_t *mqc);
+/**
+Renormalize mqc->a and mqc->c while encoding, so that mqc->a stays between 0x8000 and 0x10000
+@param mqc MQC handle
+*/
+static void mqc_renorme(opj_mqc_t *mqc);
+/**
+Encode the most probable symbol
+@param mqc MQC handle
+*/
+static void mqc_codemps(opj_mqc_t *mqc);
+/**
+Encode the most least symbol
+@param mqc MQC handle
+*/
+static void mqc_codelps(opj_mqc_t *mqc);
+/**
+Fill mqc->c with 1's for flushing
+@param mqc MQC handle
+*/
+static void mqc_setbits(opj_mqc_t *mqc);
+/**
+FIXME: documentation ???
+@param mqc MQC handle
+@return 
+*/
+static INLINE int mqc_mpsexchange(opj_mqc_t *const mqc);
+/**
+FIXME: documentation ???
+@param mqc MQC handle
+@return 
+*/
+static INLINE int mqc_lpsexchange(opj_mqc_t *const mqc);
+/**
+Input a byte
+@param mqc MQC handle
+*/
+static INLINE void mqc_bytein(opj_mqc_t *const mqc);
+/**
+Renormalize mqc->a and mqc->c while decoding
+@param mqc MQC handle
+*/
+static INLINE void mqc_renormd(opj_mqc_t *const mqc);
+/*@}*/
+
+/*@}*/
+
+/* <summary> */
+/* This array defines all the possible states for a context. */
+/* </summary> */
+static opj_mqc_state_t mqc_states[47 * 2] = {
+	{0x5601, 0, &mqc_states[2], &mqc_states[3]},
+	{0x5601, 1, &mqc_states[3], &mqc_states[2]},
+	{0x3401, 0, &mqc_states[4], &mqc_states[12]},
+	{0x3401, 1, &mqc_states[5], &mqc_states[13]},
+	{0x1801, 0, &mqc_states[6], &mqc_states[18]},
+	{0x1801, 1, &mqc_states[7], &mqc_states[19]},
+	{0x0ac1, 0, &mqc_states[8], &mqc_states[24]},
+	{0x0ac1, 1, &mqc_states[9], &mqc_states[25]},
+	{0x0521, 0, &mqc_states[10], &mqc_states[58]},
+	{0x0521, 1, &mqc_states[11], &mqc_states[59]},
+	{0x0221, 0, &mqc_states[76], &mqc_states[66]},
+	{0x0221, 1, &mqc_states[77], &mqc_states[67]},
+	{0x5601, 0, &mqc_states[14], &mqc_states[13]},
+	{0x5601, 1, &mqc_states[15], &mqc_states[12]},
+	{0x5401, 0, &mqc_states[16], &mqc_states[28]},
+	{0x5401, 1, &mqc_states[17], &mqc_states[29]},
+	{0x4801, 0, &mqc_states[18], &mqc_states[28]},
+	{0x4801, 1, &mqc_states[19], &mqc_states[29]},
+	{0x3801, 0, &mqc_states[20], &mqc_states[28]},
+	{0x3801, 1, &mqc_states[21], &mqc_states[29]},
+	{0x3001, 0, &mqc_states[22], &mqc_states[34]},
+	{0x3001, 1, &mqc_states[23], &mqc_states[35]},
+	{0x2401, 0, &mqc_states[24], &mqc_states[36]},
+	{0x2401, 1, &mqc_states[25], &mqc_states[37]},
+	{0x1c01, 0, &mqc_states[26], &mqc_states[40]},
+	{0x1c01, 1, &mqc_states[27], &mqc_states[41]},
+	{0x1601, 0, &mqc_states[58], &mqc_states[42]},
+	{0x1601, 1, &mqc_states[59], &mqc_states[43]},
+	{0x5601, 0, &mqc_states[30], &mqc_states[29]},
+	{0x5601, 1, &mqc_states[31], &mqc_states[28]},
+	{0x5401, 0, &mqc_states[32], &mqc_states[28]},
+	{0x5401, 1, &mqc_states[33], &mqc_states[29]},
+	{0x5101, 0, &mqc_states[34], &mqc_states[30]},
+	{0x5101, 1, &mqc_states[35], &mqc_states[31]},
+	{0x4801, 0, &mqc_states[36], &mqc_states[32]},
+	{0x4801, 1, &mqc_states[37], &mqc_states[33]},
+	{0x3801, 0, &mqc_states[38], &mqc_states[34]},
+	{0x3801, 1, &mqc_states[39], &mqc_states[35]},
+	{0x3401, 0, &mqc_states[40], &mqc_states[36]},
+	{0x3401, 1, &mqc_states[41], &mqc_states[37]},
+	{0x3001, 0, &mqc_states[42], &mqc_states[38]},
+	{0x3001, 1, &mqc_states[43], &mqc_states[39]},
+	{0x2801, 0, &mqc_states[44], &mqc_states[38]},
+	{0x2801, 1, &mqc_states[45], &mqc_states[39]},
+	{0x2401, 0, &mqc_states[46], &mqc_states[40]},
+	{0x2401, 1, &mqc_states[47], &mqc_states[41]},
+	{0x2201, 0, &mqc_states[48], &mqc_states[42]},
+	{0x2201, 1, &mqc_states[49], &mqc_states[43]},
+	{0x1c01, 0, &mqc_states[50], &mqc_states[44]},
+	{0x1c01, 1, &mqc_states[51], &mqc_states[45]},
+	{0x1801, 0, &mqc_states[52], &mqc_states[46]},
+	{0x1801, 1, &mqc_states[53], &mqc_states[47]},
+	{0x1601, 0, &mqc_states[54], &mqc_states[48]},
+	{0x1601, 1, &mqc_states[55], &mqc_states[49]},
+	{0x1401, 0, &mqc_states[56], &mqc_states[50]},
+	{0x1401, 1, &mqc_states[57], &mqc_states[51]},
+	{0x1201, 0, &mqc_states[58], &mqc_states[52]},
+	{0x1201, 1, &mqc_states[59], &mqc_states[53]},
+	{0x1101, 0, &mqc_states[60], &mqc_states[54]},
+	{0x1101, 1, &mqc_states[61], &mqc_states[55]},
+	{0x0ac1, 0, &mqc_states[62], &mqc_states[56]},
+	{0x0ac1, 1, &mqc_states[63], &mqc_states[57]},
+	{0x09c1, 0, &mqc_states[64], &mqc_states[58]},
+	{0x09c1, 1, &mqc_states[65], &mqc_states[59]},
+	{0x08a1, 0, &mqc_states[66], &mqc_states[60]},
+	{0x08a1, 1, &mqc_states[67], &mqc_states[61]},
+	{0x0521, 0, &mqc_states[68], &mqc_states[62]},
+	{0x0521, 1, &mqc_states[69], &mqc_states[63]},
+	{0x0441, 0, &mqc_states[70], &mqc_states[64]},
+	{0x0441, 1, &mqc_states[71], &mqc_states[65]},
+	{0x02a1, 0, &mqc_states[72], &mqc_states[66]},
+	{0x02a1, 1, &mqc_states[73], &mqc_states[67]},
+	{0x0221, 0, &mqc_states[74], &mqc_states[68]},
+	{0x0221, 1, &mqc_states[75], &mqc_states[69]},
+	{0x0141, 0, &mqc_states[76], &mqc_states[70]},
+	{0x0141, 1, &mqc_states[77], &mqc_states[71]},
+	{0x0111, 0, &mqc_states[78], &mqc_states[72]},
+	{0x0111, 1, &mqc_states[79], &mqc_states[73]},
+	{0x0085, 0, &mqc_states[80], &mqc_states[74]},
+	{0x0085, 1, &mqc_states[81], &mqc_states[75]},
+	{0x0049, 0, &mqc_states[82], &mqc_states[76]},
+	{0x0049, 1, &mqc_states[83], &mqc_states[77]},
+	{0x0025, 0, &mqc_states[84], &mqc_states[78]},
+	{0x0025, 1, &mqc_states[85], &mqc_states[79]},
+	{0x0015, 0, &mqc_states[86], &mqc_states[80]},
+	{0x0015, 1, &mqc_states[87], &mqc_states[81]},
+	{0x0009, 0, &mqc_states[88], &mqc_states[82]},
+	{0x0009, 1, &mqc_states[89], &mqc_states[83]},
+	{0x0005, 0, &mqc_states[90], &mqc_states[84]},
+	{0x0005, 1, &mqc_states[91], &mqc_states[85]},
+	{0x0001, 0, &mqc_states[90], &mqc_states[86]},
+	{0x0001, 1, &mqc_states[91], &mqc_states[87]},
+	{0x5601, 0, &mqc_states[92], &mqc_states[92]},
+	{0x5601, 1, &mqc_states[93], &mqc_states[93]},
+};
+
+/* 
+==========================================================
+   local functions
+==========================================================
+*/
+
+static void mqc_byteout(opj_mqc_t *mqc) {
+	if (*mqc->bp == 0xff) {
+		mqc->bp++;
+		*mqc->bp = mqc->c >> 20;
+		mqc->c &= 0xfffff;
+		mqc->ct = 7;
+	} else {
+		if ((mqc->c & 0x8000000) == 0) {	/* ((mqc->c&0x8000000)==0) CHANGE */
+			mqc->bp++;
+			*mqc->bp = mqc->c >> 19;
+			mqc->c &= 0x7ffff;
+			mqc->ct = 8;
+		} else {
+			(*mqc->bp)++;
+			if (*mqc->bp == 0xff) {
+				mqc->c &= 0x7ffffff;
+				mqc->bp++;
+				*mqc->bp = mqc->c >> 20;
+				mqc->c &= 0xfffff;
+				mqc->ct = 7;
+			} else {
+				mqc->bp++;
+				*mqc->bp = mqc->c >> 19;
+				mqc->c &= 0x7ffff;
+				mqc->ct = 8;
+			}
+		}
+	}
+}
+
+static void mqc_renorme(opj_mqc_t *mqc) {
+	do {
+		mqc->a <<= 1;
+		mqc->c <<= 1;
+		mqc->ct--;
+		if (mqc->ct == 0) {
+			mqc_byteout(mqc);
+		}
+	} while ((mqc->a & 0x8000) == 0);
+}
+
+static void mqc_codemps(opj_mqc_t *mqc) {
+	mqc->a -= (*mqc->curctx)->qeval;
+	if ((mqc->a & 0x8000) == 0) {
+		if (mqc->a < (*mqc->curctx)->qeval) {
+			mqc->a = (*mqc->curctx)->qeval;
+		} else {
+			mqc->c += (*mqc->curctx)->qeval;
+		}
+		*mqc->curctx = (*mqc->curctx)->nmps;
+		mqc_renorme(mqc);
+	} else {
+		mqc->c += (*mqc->curctx)->qeval;
+	}
+}
+
+static void mqc_codelps(opj_mqc_t *mqc) {
+	mqc->a -= (*mqc->curctx)->qeval;
+	if (mqc->a < (*mqc->curctx)->qeval) {
+		mqc->c += (*mqc->curctx)->qeval;
+	} else {
+		mqc->a = (*mqc->curctx)->qeval;
+	}
+	*mqc->curctx = (*mqc->curctx)->nlps;
+	mqc_renorme(mqc);
+}
+
+static void mqc_setbits(opj_mqc_t *mqc) {
+	unsigned int tempc = mqc->c + mqc->a;
+	mqc->c |= 0xffff;
+	if (mqc->c >= tempc) {
+		mqc->c -= 0x8000;
+	}
+}
+
+static INLINE int mqc_mpsexchange(opj_mqc_t *const mqc) {
+	int d;
+	if (mqc->a < (*mqc->curctx)->qeval) {
+		d = 1 - (*mqc->curctx)->mps;
+		*mqc->curctx = (*mqc->curctx)->nlps;
+	} else {
+		d = (*mqc->curctx)->mps;
+		*mqc->curctx = (*mqc->curctx)->nmps;
+	}
+	
+	return d;
+}
+
+static INLINE int mqc_lpsexchange(opj_mqc_t *const mqc) {
+	int d;
+	if (mqc->a < (*mqc->curctx)->qeval) {
+		mqc->a = (*mqc->curctx)->qeval;
+		d = (*mqc->curctx)->mps;
+		*mqc->curctx = (*mqc->curctx)->nmps;
+	} else {
+		mqc->a = (*mqc->curctx)->qeval;
+		d = 1 - (*mqc->curctx)->mps;
+		*mqc->curctx = (*mqc->curctx)->nlps;
+	}
+	
+	return d;
+}
+
+#ifdef MQC_PERF_OPT
+static INLINE void mqc_bytein(opj_mqc_t *const mqc) {
+	unsigned int i = *((unsigned int *) mqc->bp);
+	mqc->c += i & 0xffff00;
+	mqc->ct = i & 0x0f;
+	mqc->bp += (i >> 2) & 0x04;
+}
+#else
+static void mqc_bytein(opj_mqc_t *const mqc) {
+	if (mqc->bp != mqc->end) {
+		unsigned int c;
+		if (mqc->bp + 1 != mqc->end) {
+			c = *(mqc->bp + 1);
+		} else {
+			c = 0xff;
+		}
+		if (*mqc->bp == 0xff) {
+			if (c > 0x8f) {
+				mqc->c += 0xff00;
+				mqc->ct = 8;
+			} else {
+				mqc->bp++;
+				mqc->c += c << 9;
+				mqc->ct = 7;
+			}
+		} else {
+			mqc->bp++;
+			mqc->c += c << 8;
+			mqc->ct = 8;
+		}
+	} else {
+		mqc->c += 0xff00;
+		mqc->ct = 8;
+	}
+}
+#endif
+
+static INLINE void mqc_renormd(opj_mqc_t *const mqc) {
+	do {
+		if (mqc->ct == 0) {
+			mqc_bytein(mqc);
+		}
+		mqc->a <<= 1;
+		mqc->c <<= 1;
+		mqc->ct--;
+	} while (mqc->a < 0x8000);
+}
+
+/* 
+==========================================================
+   MQ-Coder interface
+==========================================================
+*/
+
+opj_mqc_t* mqc_create(void) {
+	opj_mqc_t *mqc = (opj_mqc_t*)opj_malloc(sizeof(opj_mqc_t));
+#ifdef MQC_PERF_OPT
+	mqc->buffer = NULL;
+#endif
+	return mqc;
+}
+
+void mqc_destroy(opj_mqc_t *mqc) {
+	if(mqc) {
+#ifdef MQC_PERF_OPT
+		if (mqc->buffer) {
+			opj_free(mqc->buffer);
+		}
+#endif
+		opj_free(mqc);
+	}
+}
+
+int mqc_numbytes(opj_mqc_t *mqc) {
+	return mqc->bp - mqc->start;
+}
+
+void mqc_init_enc(opj_mqc_t *mqc, unsigned char *bp) {
+	mqc_setcurctx(mqc, 0);
+	mqc->a = 0x8000;
+	mqc->c = 0;
+	mqc->bp = bp - 1;
+	mqc->ct = 12;
+	if (*mqc->bp == 0xff) {
+		mqc->ct = 13;
+	}
+	mqc->start = bp;
+}
+
+void mqc_encode(opj_mqc_t *mqc, int d) {
+	if ((*mqc->curctx)->mps == d) {
+		mqc_codemps(mqc);
+	} else {
+		mqc_codelps(mqc);
+	}
+}
+
+void mqc_flush(opj_mqc_t *mqc) {
+	mqc_setbits(mqc);
+	mqc->c <<= mqc->ct;
+	mqc_byteout(mqc);
+	mqc->c <<= mqc->ct;
+	mqc_byteout(mqc);
+	
+	if (*mqc->bp != 0xff) {
+		mqc->bp++;
+	}
+}
+
+void mqc_bypass_init_enc(opj_mqc_t *mqc) {
+	mqc->c = 0;
+	mqc->ct = 8;
+	/*if (*mqc->bp == 0xff) {
+	mqc->ct = 7;
+     } */
+}
+
+void mqc_bypass_enc(opj_mqc_t *mqc, int d) {
+	mqc->ct--;
+	mqc->c = mqc->c + (d << mqc->ct);
+	if (mqc->ct == 0) {
+		mqc->bp++;
+		*mqc->bp = mqc->c;
+		mqc->ct = 8;
+		if (*mqc->bp == 0xff) {
+			mqc->ct = 7;
+		}
+		mqc->c = 0;
+	}
+}
+
+int mqc_bypass_flush_enc(opj_mqc_t *mqc) {
+	unsigned char bit_padding;
+	
+	bit_padding = 0;
+	
+	if (mqc->ct != 0) {
+		while (mqc->ct > 0) {
+			mqc->ct--;
+			mqc->c += bit_padding << mqc->ct;
+			bit_padding = (bit_padding + 1) & 0x01;
+		}
+		mqc->bp++;
+		*mqc->bp = mqc->c;
+		mqc->ct = 8;
+		mqc->c = 0;
+	}
+	
+	return 1;
+}
+
+void mqc_reset_enc(opj_mqc_t *mqc) {
+	mqc_resetstates(mqc);
+	mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
+	mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
+	mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
+}
+
+int mqc_restart_enc(opj_mqc_t *mqc) {
+	int correction = 1;
+	
+	/* <flush part> */
+	int n = 27 - 15 - mqc->ct;
+	mqc->c <<= mqc->ct;
+	while (n > 0) {
+		mqc_byteout(mqc);
+		n -= mqc->ct;
+		mqc->c <<= mqc->ct;
+	}
+	mqc_byteout(mqc);
+	
+	return correction;
+}
+
+void mqc_restart_init_enc(opj_mqc_t *mqc) {
+	/* <Re-init part> */
+	mqc_setcurctx(mqc, 0);
+	mqc->a = 0x8000;
+	mqc->c = 0;
+	mqc->ct = 12;
+	mqc->bp--;
+	if (*mqc->bp == 0xff) {
+		mqc->ct = 13;
+	}
+}
+
+void mqc_erterm_enc(opj_mqc_t *mqc) {
+	int k = 11 - mqc->ct + 1;
+	
+	while (k > 0) {
+		mqc->c <<= mqc->ct;
+		mqc->ct = 0;
+		mqc_byteout(mqc);
+		k -= mqc->ct;
+	}
+	
+	if (*mqc->bp != 0xff) {
+		mqc_byteout(mqc);
+	}
+}
+
+void mqc_segmark_enc(opj_mqc_t *mqc) {
+	int i;
+	mqc_setcurctx(mqc, 18);
+	
+	for (i = 1; i < 5; i++) {
+		mqc_encode(mqc, i % 2);
+	}
+}
+
+void mqc_init_dec(opj_mqc_t *mqc, unsigned char *bp, int len) {
+	mqc_setcurctx(mqc, 0);
+	mqc->start = bp;
+	mqc->end = bp + len;
+	mqc->bp = bp;
+	if (len==0) mqc->c = 0xff << 16;
+	else mqc->c = *mqc->bp << 16;
+
+#ifdef MQC_PERF_OPT
+	{
+		unsigned int c;
+		unsigned int *ip;
+		unsigned char *end = mqc->end - 1;
+		mqc->buffer = opj_realloc(mqc->buffer, (len + 1) * sizeof(unsigned int));
+		ip = (unsigned int *) mqc->buffer;
+
+		while (bp < end) {
+			c = *(bp + 1);
+			if (*bp == 0xff) {
+				if (c > 0x8f) {
+					break;
+				} else {
+					*ip = 0x00000017 | (c << 9);
+				}
+			} else {
+				*ip = 0x00000018 | (c << 8);
+			}
+			bp++;
+			ip++;
+		}
+
+		/* Handle last byte of data */
+		c = 0xff;
+		if (*bp == 0xff) {
+			*ip = 0x0000ff18;
+		} else {
+			bp++;
+			*ip = 0x00000018 | (c << 8);
+		}
+		ip++;
+
+		*ip = 0x0000ff08;
+		mqc->bp = mqc->buffer;
+	}
+#endif
+	mqc_bytein(mqc);
+	mqc->c <<= 7;
+	mqc->ct -= 7;
+	mqc->a = 0x8000;
+}
+
+int mqc_decode(opj_mqc_t *const mqc) {
+	int d;
+	mqc->a -= (*mqc->curctx)->qeval;
+	if ((mqc->c >> 16) < (*mqc->curctx)->qeval) {
+		d = mqc_lpsexchange(mqc);
+		mqc_renormd(mqc);
+	} else {
+		mqc->c -= (*mqc->curctx)->qeval << 16;
+		if ((mqc->a & 0x8000) == 0) {
+			d = mqc_mpsexchange(mqc);
+			mqc_renormd(mqc);
+		} else {
+			d = (*mqc->curctx)->mps;
+		}
+	}
+
+	return d;
+}
+
+void mqc_resetstates(opj_mqc_t *mqc) {
+	int i;
+	for (i = 0; i < MQC_NUMCTXS; i++) {
+		mqc->ctxs[i] = mqc_states;
+	}
+}
+
+void mqc_setstate(opj_mqc_t *mqc, int ctxno, int msb, int prob) {
+	mqc->ctxs[ctxno] = &mqc_states[msb + (prob << 1)];
+}
+
+

src/add-ons/translators/icns/openjpeg/mqc.h

@@ -0,0 +1,200 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __MQC_H
+#define __MQC_H
+/**
+@file mqc.h
+@brief Implementation of an MQ-Coder (MQC)
+
+The functions in MQC.C have for goal to realize the MQ-coder operations. The functions
+in MQC.C are used by some function in T1.C.
+*/
+
+/** @defgroup MQC MQC - Implementation of an MQ-Coder */
+/*@{*/
+
+/**
+This struct defines the state of a context.
+*/
+typedef struct opj_mqc_state {
+	/** the probability of the Least Probable Symbol (0.75->0x8000, 1.5->0xffff) */
+	unsigned int qeval;
+	/** the Most Probable Symbol (0 or 1) */
+	int mps;
+	/** next state if the next encoded symbol is the MPS */
+	struct opj_mqc_state *nmps;
+	/** next state if the next encoded symbol is the LPS */
+	struct opj_mqc_state *nlps;
+} opj_mqc_state_t;
+
+#define MQC_NUMCTXS 19
+
+/**
+MQ coder
+*/
+typedef struct opj_mqc {
+	unsigned int c;
+	unsigned int a;
+	unsigned int ct;
+	unsigned char *bp;
+	unsigned char *start;
+	unsigned char *end;
+	opj_mqc_state_t *ctxs[MQC_NUMCTXS];
+	opj_mqc_state_t **curctx;
+#ifdef MQC_PERF_OPT
+	unsigned char *buffer;
+#endif
+} opj_mqc_t;
+
+/** @name Exported functions */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+/**
+Create a new MQC handle 
+@return Returns a new MQC handle if successful, returns NULL otherwise
+*/
+opj_mqc_t* mqc_create(void);
+/**
+Destroy a previously created MQC handle
+@param mqc MQC handle to destroy
+*/
+void mqc_destroy(opj_mqc_t *mqc);
+/**
+Return the number of bytes written/read since initialisation
+@param mqc MQC handle
+@return Returns the number of bytes already encoded
+*/
+int mqc_numbytes(opj_mqc_t *mqc);
+/**
+Reset the states of all the context of the coder/decoder 
+(each context is set to a state where 0 and 1 are more or less equiprobable)
+@param mqc MQC handle
+*/
+void mqc_resetstates(opj_mqc_t *mqc);
+/**
+Set the state of a particular context
+@param mqc MQC handle
+@param ctxno Number that identifies the context
+@param msb The MSB of the new state of the context
+@param prob Number that identifies the probability of the symbols for the new state of the context
+*/
+void mqc_setstate(opj_mqc_t *mqc, int ctxno, int msb, int prob);
+/**
+Initialize the encoder
+@param mqc MQC handle
+@param bp Pointer to the start of the buffer where the bytes will be written
+*/
+void mqc_init_enc(opj_mqc_t *mqc, unsigned char *bp);
+/**
+Set the current context used for coding/decoding
+@param mqc MQC handle
+@param ctxno Number that identifies the context
+*/
+#define mqc_setcurctx(mqc, ctxno)	(mqc)->curctx = &(mqc)->ctxs[(int)(ctxno)]
+/**
+Encode a symbol using the MQ-coder
+@param mqc MQC handle
+@param d The symbol to be encoded (0 or 1)
+*/
+void mqc_encode(opj_mqc_t *mqc, int d);
+/**
+Flush the encoder, so that all remaining data is written
+@param mqc MQC handle
+*/
+void mqc_flush(opj_mqc_t *mqc);
+/**
+BYPASS mode switch, initialization operation. 
+JPEG 2000 p 505. 
+<h2>Not fully implemented and tested !!</h2>
+@param mqc MQC handle
+*/
+void mqc_bypass_init_enc(opj_mqc_t *mqc);
+/**
+BYPASS mode switch, coding operation. 
+JPEG 2000 p 505. 
+<h2>Not fully implemented and tested !!</h2>
+@param mqc MQC handle
+@param d The symbol to be encoded (0 or 1)
+*/
+void mqc_bypass_enc(opj_mqc_t *mqc, int d);
+/**
+BYPASS mode switch, flush operation
+<h2>Not fully implemented and tested !!</h2>
+@param mqc MQC handle
+@return Returns 1 (always)
+*/
+int mqc_bypass_flush_enc(opj_mqc_t *mqc);
+/**
+RESET mode switch
+@param mqc MQC handle
+*/
+void mqc_reset_enc(opj_mqc_t *mqc);
+/**
+RESTART mode switch (TERMALL)
+@param mqc MQC handle
+@return Returns 1 (always)
+*/
+int mqc_restart_enc(opj_mqc_t *mqc);
+/**
+RESTART mode switch (TERMALL) reinitialisation
+@param mqc MQC handle
+*/
+void mqc_restart_init_enc(opj_mqc_t *mqc);
+/**
+ERTERM mode switch (PTERM)
+@param mqc MQC handle
+*/
+void mqc_erterm_enc(opj_mqc_t *mqc);
+/**
+SEGMARK mode switch (SEGSYM)
+@param mqc MQC handle
+*/
+void mqc_segmark_enc(opj_mqc_t *mqc);
+/**
+Initialize the decoder
+@param mqc MQC handle
+@param bp Pointer to the start of the buffer from which the bytes will be read
+@param len Length of the input buffer
+*/
+void mqc_init_dec(opj_mqc_t *mqc, unsigned char *bp, int len);
+/**
+Decode a symbol
+@param mqc MQC handle
+@return Returns the decoded symbol (0 or 1)
+*/
+int mqc_decode(opj_mqc_t *const mqc);
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __MQC_H */

src/add-ons/translators/icns/openjpeg/oj_image.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __IMAGE_H
+#define __IMAGE_H
+/**
+@file image.h
+@brief Implementation of operations on images (IMAGE)
+
+The functions in IMAGE.C have for goal to realize operations on images.
+*/
+
+/** @defgroup IMAGE IMAGE - Implementation of operations on images */
+/*@{*/
+
+/**
+Create an empty image
+@todo this function should be removed
+@return returns an empty image if successful, returns NULL otherwise
+*/
+opj_image_t* opj_image_create0(void);
+
+/*@}*/
+
+#endif /* __IMAGE_H */
+

src/add-ons/translators/icns/openjpeg/openjpeg.c

@@ -0,0 +1,343 @@
+/*
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifdef _WIN32
+#include <windows.h>
+#endif /* _WIN32 */
+
+#include "opj_config.h"
+#include "opj_includes.h"
+
+/* ---------------------------------------------------------------------- */
+#ifdef _WIN32
+#ifndef OPJ_STATIC
+BOOL APIENTRY
+DllMain(HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) {
+
+	OPJ_ARG_NOT_USED(lpReserved);
+	OPJ_ARG_NOT_USED(hModule);
+
+	switch (ul_reason_for_call) {
+		case DLL_PROCESS_ATTACH :
+			break;
+		case DLL_PROCESS_DETACH :
+			break;
+		case DLL_THREAD_ATTACH :
+		case DLL_THREAD_DETACH :
+			break;
+    }
+
+    return TRUE;
+}
+#endif /* OPJ_STATIC */
+#endif /* _WIN32 */
+
+/* ---------------------------------------------------------------------- */
+
+
+const char* OPJ_CALLCONV opj_version(void) {
+    return PACKAGE_VERSION;
+}
+
+opj_dinfo_t* OPJ_CALLCONV opj_create_decompress(OPJ_CODEC_FORMAT format) {
+	opj_dinfo_t *dinfo = (opj_dinfo_t*)opj_calloc(1, sizeof(opj_dinfo_t));
+	if(!dinfo) return NULL;
+	dinfo->is_decompressor = OPJ_TRUE;
+	switch(format) {
+		case CODEC_J2K:
+		case CODEC_JPT:
+			/* get a J2K decoder handle */
+			dinfo->j2k_handle = (void*)j2k_create_decompress((opj_common_ptr)dinfo);
+			if(!dinfo->j2k_handle) {
+				opj_free(dinfo);
+				return NULL;
+			}
+			break;
+		case CODEC_JP2:
+			/* get a JP2 decoder handle */
+			dinfo->jp2_handle = (void*)jp2_create_decompress((opj_common_ptr)dinfo);
+			if(!dinfo->jp2_handle) {
+				opj_free(dinfo);
+				return NULL;
+			}
+			break;
+		case CODEC_UNKNOWN:
+		default:
+			opj_free(dinfo);
+			return NULL;
+	}
+
+	dinfo->codec_format = format;
+
+	return dinfo;
+}
+
+void OPJ_CALLCONV opj_destroy_decompress(opj_dinfo_t *dinfo) {
+	if(dinfo) {
+		/* destroy the codec */
+		switch(dinfo->codec_format) {
+			case CODEC_J2K:
+			case CODEC_JPT:
+				j2k_destroy_decompress((opj_j2k_t*)dinfo->j2k_handle);
+				break;
+			case CODEC_JP2:
+				jp2_destroy_decompress((opj_jp2_t*)dinfo->jp2_handle);
+				break;
+			case CODEC_UNKNOWN:
+			default:
+				break;
+		}
+		/* destroy the decompressor */
+		opj_free(dinfo);
+	}
+}
+
+void OPJ_CALLCONV opj_set_default_decoder_parameters(opj_dparameters_t *parameters) {
+	if(parameters) {
+		memset(parameters, 0, sizeof(opj_dparameters_t));
+		/* default decoding parameters */
+		parameters->cp_layer = 0;
+		parameters->cp_reduce = 0;
+		parameters->cp_limit_decoding = NO_LIMITATION;
+
+		parameters->decod_format = -1;
+		parameters->cod_format = -1;
+		parameters->flags = 0;		
+/* UniPG>> */
+#ifdef USE_JPWL
+		parameters->jpwl_correct = OPJ_FALSE;
+		parameters->jpwl_exp_comps = JPWL_EXPECTED_COMPONENTS;
+		parameters->jpwl_max_tiles = JPWL_MAXIMUM_TILES;
+#endif /* USE_JPWL */
+/* <<UniPG */
+	}
+}
+
+void OPJ_CALLCONV opj_setup_decoder(opj_dinfo_t *dinfo, opj_dparameters_t *parameters) {
+	if(dinfo && parameters) {
+		switch(dinfo->codec_format) {
+			case CODEC_J2K:
+			case CODEC_JPT:
+				j2k_setup_decoder((opj_j2k_t*)dinfo->j2k_handle, parameters);
+				break;
+			case CODEC_JP2:
+				jp2_setup_decoder((opj_jp2_t*)dinfo->jp2_handle, parameters);
+				break;
+			case CODEC_UNKNOWN:
+			default:
+				break;
+		}
+	}
+}
+
+opj_image_t* OPJ_CALLCONV opj_decode(opj_dinfo_t *dinfo, opj_cio_t *cio) {
+	return opj_decode_with_info(dinfo, cio, NULL);
+}
+
+opj_image_t* OPJ_CALLCONV opj_decode_with_info(opj_dinfo_t *dinfo, opj_cio_t *cio, opj_codestream_info_t *cstr_info) {
+	if(dinfo && cio) {
+		switch(dinfo->codec_format) {
+			case CODEC_J2K:
+				return j2k_decode((opj_j2k_t*)dinfo->j2k_handle, cio, cstr_info);
+			case CODEC_JPT:
+				return j2k_decode_jpt_stream((opj_j2k_t*)dinfo->j2k_handle, cio, cstr_info);
+			case CODEC_JP2:
+				return opj_jp2_decode((opj_jp2_t*)dinfo->jp2_handle, cio, cstr_info);
+			case CODEC_UNKNOWN:
+			default:
+				break;
+		}
+	}
+	return NULL;
+}
+
+opj_cinfo_t* OPJ_CALLCONV opj_create_compress(OPJ_CODEC_FORMAT format) {
+	opj_cinfo_t *cinfo = (opj_cinfo_t*)opj_calloc(1, sizeof(opj_cinfo_t));
+	if(!cinfo) return NULL;
+	cinfo->is_decompressor = OPJ_FALSE;
+	switch(format) {
+		case CODEC_J2K:
+			/* get a J2K coder handle */
+			cinfo->j2k_handle = (void*)j2k_create_compress((opj_common_ptr)cinfo);
+			if(!cinfo->j2k_handle) {
+				opj_free(cinfo);
+				return NULL;
+			}
+			break;
+		case CODEC_JP2:
+			/* get a JP2 coder handle */
+			cinfo->jp2_handle = (void*)jp2_create_compress((opj_common_ptr)cinfo);
+			if(!cinfo->jp2_handle) {
+				opj_free(cinfo);
+				return NULL;
+			}
+			break;
+		case CODEC_JPT:
+		case CODEC_UNKNOWN:
+		default:
+			opj_free(cinfo);
+			return NULL;
+	}
+
+	cinfo->codec_format = format;
+
+	return cinfo;
+}
+
+void OPJ_CALLCONV opj_destroy_compress(opj_cinfo_t *cinfo) {
+	if(cinfo) {
+		/* destroy the codec */
+		switch(cinfo->codec_format) {
+			case CODEC_J2K:
+				j2k_destroy_compress((opj_j2k_t*)cinfo->j2k_handle);
+				break;
+			case CODEC_JP2:
+				jp2_destroy_compress((opj_jp2_t*)cinfo->jp2_handle);
+				break;
+			case CODEC_JPT:
+			case CODEC_UNKNOWN:
+			default:
+				break;
+		}
+		/* destroy the decompressor */
+		opj_free(cinfo);
+	}
+}
+
+void OPJ_CALLCONV opj_set_default_encoder_parameters(opj_cparameters_t *parameters) {
+	if(parameters) {
+		memset(parameters, 0, sizeof(opj_cparameters_t));
+		/* default coding parameters */
+		parameters->cp_cinema = OFF; 
+		parameters->max_comp_size = 0;
+		parameters->numresolution = 6;
+		parameters->cp_rsiz = STD_RSIZ;
+		parameters->cblockw_init = 64;
+		parameters->cblockh_init = 64;
+		parameters->prog_order = LRCP;
+		parameters->roi_compno = -1;		/* no ROI */
+		parameters->subsampling_dx = 1;
+		parameters->subsampling_dy = 1;
+		parameters->tp_on = 0;
+		parameters->decod_format = -1;
+		parameters->cod_format = -1;
+		parameters->tcp_rates[0] = 0;   
+		parameters->tcp_numlayers = 0;
+    parameters->cp_disto_alloc = 0;
+		parameters->cp_fixed_alloc = 0;
+		parameters->cp_fixed_quality = 0;
+		parameters->jpip_on = OPJ_FALSE;
+/* UniPG>> */
+#ifdef USE_JPWL
+		parameters->jpwl_epc_on = OPJ_FALSE;
+		parameters->jpwl_hprot_MH = -1; /* -1 means unassigned */
+		{
+			int i;
+			for (i = 0; i < JPWL_MAX_NO_TILESPECS; i++) {
+				parameters->jpwl_hprot_TPH_tileno[i] = -1; /* unassigned */
+				parameters->jpwl_hprot_TPH[i] = 0; /* absent */
+			}
+		};
+		{
+			int i;
+			for (i = 0; i < JPWL_MAX_NO_PACKSPECS; i++) {
+				parameters->jpwl_pprot_tileno[i] = -1; /* unassigned */
+				parameters->jpwl_pprot_packno[i] = -1; /* unassigned */
+				parameters->jpwl_pprot[i] = 0; /* absent */
+			}
+		};
+		parameters->jpwl_sens_size = 0; /* 0 means no ESD */
+		parameters->jpwl_sens_addr = 0; /* 0 means auto */
+		parameters->jpwl_sens_range = 0; /* 0 means packet */
+		parameters->jpwl_sens_MH = -1; /* -1 means unassigned */
+		{
+			int i;
+			for (i = 0; i < JPWL_MAX_NO_TILESPECS; i++) {
+				parameters->jpwl_sens_TPH_tileno[i] = -1; /* unassigned */
+				parameters->jpwl_sens_TPH[i] = -1; /* absent */
+			}
+		};
+#endif /* USE_JPWL */
+/* <<UniPG */
+	}
+}
+
+void OPJ_CALLCONV opj_setup_encoder(opj_cinfo_t *cinfo, opj_cparameters_t *parameters, opj_image_t *image) {
+	if(cinfo && parameters && image) {
+		switch(cinfo->codec_format) {
+			case CODEC_J2K:
+				j2k_setup_encoder((opj_j2k_t*)cinfo->j2k_handle, parameters, image);
+				break;
+			case CODEC_JP2:
+				jp2_setup_encoder((opj_jp2_t*)cinfo->jp2_handle, parameters, image);
+				break;
+			case CODEC_JPT:
+			case CODEC_UNKNOWN:
+			default:
+				break;
+		}
+	}
+}
+
+opj_bool OPJ_CALLCONV opj_encode(opj_cinfo_t *cinfo, opj_cio_t *cio, opj_image_t *image, char *index) {
+	if (index != NULL)
+		opj_event_msg((opj_common_ptr)cinfo, EVT_WARNING, "Set index to NULL when calling the opj_encode function.\n"
+		"To extract the index, use the opj_encode_with_info() function.\n"
+		"No index will be generated during this encoding\n");
+	return opj_encode_with_info(cinfo, cio, image, NULL);
+}
+
+opj_bool OPJ_CALLCONV opj_encode_with_info(opj_cinfo_t *cinfo, opj_cio_t *cio, opj_image_t *image, opj_codestream_info_t *cstr_info) {
+	if(cinfo && cio && image) {
+		switch(cinfo->codec_format) {
+			case CODEC_J2K:
+				return j2k_encode((opj_j2k_t*)cinfo->j2k_handle, cio, image, cstr_info);
+			case CODEC_JP2:
+				return opj_jp2_encode((opj_jp2_t*)cinfo->jp2_handle, cio, image, cstr_info);	    
+			case CODEC_JPT:
+			case CODEC_UNKNOWN:
+			default:
+				break;
+		}
+	}
+	return OPJ_FALSE;
+}
+
+void OPJ_CALLCONV opj_destroy_cstr_info(opj_codestream_info_t *cstr_info) {
+	if (cstr_info) {
+		int tileno;
+		for (tileno = 0; tileno < cstr_info->tw * cstr_info->th; tileno++) {
+			opj_tile_info_t *tile_info = &cstr_info->tile[tileno];
+			opj_free(tile_info->thresh);
+			opj_free(tile_info->packet);
+			opj_free(tile_info->tp);
+			opj_free(tile_info->marker);
+		}
+		opj_free(cstr_info->tile);
+		opj_free(cstr_info->marker);
+		opj_free(cstr_info->numdecompos);
+	}
+}

src/add-ons/translators/icns/openjpeg/openjpeg.h

@@ -0,0 +1,914 @@
+ /*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * Copyright (c) 2006-2007, Parvatha Elangovan
+ * Copyright (c) 2010-2011, Kaori Hagihara
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef OPENJPEG_H
+#define OPENJPEG_H
+
+
+/* 
+==========================================================
+   Compiler directives
+==========================================================
+*/
+
+#if defined(OPJ_STATIC) || !defined(_WIN32)
+#define OPJ_API
+#define OPJ_CALLCONV
+#else
+#define OPJ_CALLCONV __stdcall
+/*
+The following ifdef block is the standard way of creating macros which make exporting 
+from a DLL simpler. All files within this DLL are compiled with the OPJ_EXPORTS
+symbol defined on the command line. this symbol should not be defined on any project
+that uses this DLL. This way any other project whose source files include this file see 
+OPJ_API functions as being imported from a DLL, wheras this DLL sees symbols
+defined with this macro as being exported.
+*/
+#if defined(OPJ_EXPORTS) || defined(DLL_EXPORT)
+#define OPJ_API __declspec(dllexport)
+#else
+#define OPJ_API __declspec(dllimport)
+#endif /* OPJ_EXPORTS */
+#endif /* !OPJ_STATIC || !_WIN32 */
+
+typedef int opj_bool;
+#define OPJ_TRUE 1
+#define OPJ_FALSE 0
+
+/* Avoid compile-time warning because parameter is not used */
+#define OPJ_ARG_NOT_USED(x) (void)(x)
+/* 
+==========================================================
+   Useful constant definitions
+==========================================================
+*/
+
+#define OPJ_PATH_LEN 4096 /**< Maximum allowed size for filenames */
+
+#define J2K_MAXRLVLS 33					/**< Number of maximum resolution level authorized */
+#define J2K_MAXBANDS (3*J2K_MAXRLVLS-2)	/**< Number of maximum sub-band linked to number of resolution level */
+
+/* UniPG>> */
+#define JPWL_MAX_NO_TILESPECS	16 /**< Maximum number of tile parts expected by JPWL: increase at your will */
+#define JPWL_MAX_NO_PACKSPECS	16 /**< Maximum number of packet parts expected by JPWL: increase at your will */
+#define JPWL_MAX_NO_MARKERS	512 /**< Maximum number of JPWL markers: increase at your will */
+#define JPWL_PRIVATEINDEX_NAME "jpwl_index_privatefilename" /**< index file name used when JPWL is on */
+#define JPWL_EXPECTED_COMPONENTS 3 /**< Expect this number of components, so you'll find better the first EPB */
+#define JPWL_MAXIMUM_TILES 8192 /**< Expect this maximum number of tiles, to avoid some crashes */
+#define JPWL_MAXIMUM_HAMMING 2 /**< Expect this maximum number of bit errors in marker id's */
+#define JPWL_MAXIMUM_EPB_ROOM 65450 /**< Expect this maximum number of bytes for composition of EPBs */
+/* <<UniPG */
+
+/* 
+==========================================================
+   enum definitions
+==========================================================
+*/
+/** 
+Rsiz Capabilities
+*/
+typedef enum RSIZ_CAPABILITIES {
+	STD_RSIZ = 0,		/** Standard JPEG2000 profile*/
+	CINEMA2K = 3,		/** Profile name for a 2K image*/
+	CINEMA4K = 4		/** Profile name for a 4K image*/
+} OPJ_RSIZ_CAPABILITIES;
+
+/** 
+Digital cinema operation mode 
+*/
+typedef enum CINEMA_MODE {
+	OFF = 0,					/** Not Digital Cinema*/
+	CINEMA2K_24 = 1,	/** 2K Digital Cinema at 24 fps*/
+	CINEMA2K_48 = 2,	/** 2K Digital Cinema at 48 fps*/
+	CINEMA4K_24 = 3		/** 4K Digital Cinema at 24 fps*/
+}OPJ_CINEMA_MODE;
+
+/** 
+Progression order 
+*/
+typedef enum PROG_ORDER {
+	PROG_UNKNOWN = -1,	/**< place-holder */
+	LRCP = 0,		/**< layer-resolution-component-precinct order */
+	RLCP = 1,		/**< resolution-layer-component-precinct order */
+	RPCL = 2,		/**< resolution-precinct-component-layer order */
+	PCRL = 3,		/**< precinct-component-resolution-layer order */
+	CPRL = 4		/**< component-precinct-resolution-layer order */
+} OPJ_PROG_ORDER;
+
+/**
+Supported image color spaces
+*/
+typedef enum COLOR_SPACE {
+	CLRSPC_UNKNOWN = -1,	/**< not supported by the library */
+	CLRSPC_UNSPECIFIED = 0, /**< not specified in the codestream */ 
+	CLRSPC_SRGB = 1,		/**< sRGB */
+	CLRSPC_GRAY = 2,		/**< grayscale */
+	CLRSPC_SYCC = 3			/**< YUV */
+} OPJ_COLOR_SPACE;
+
+#define ENUMCS_SRGB 16
+#define ENUMCS_GRAY 17
+#define ENUMCS_SYCC 18
+
+/**
+Supported codec
+*/
+typedef enum CODEC_FORMAT {
+	CODEC_UNKNOWN = -1,	/**< place-holder */
+	CODEC_J2K  = 0,		/**< JPEG-2000 codestream : read/write */
+	CODEC_JPT  = 1,		/**< JPT-stream (JPEG 2000, JPIP) : read only */
+	CODEC_JP2  = 2 		/**< JPEG-2000 file format : read/write */
+} OPJ_CODEC_FORMAT;
+
+/** 
+Limit decoding to certain portions of the codestream. 
+*/
+typedef enum LIMIT_DECODING {
+	NO_LIMITATION = 0,				  /**< No limitation for the decoding. The entire codestream will de decoded */
+	LIMIT_TO_MAIN_HEADER = 1,		/**< The decoding is limited to the Main Header */
+	DECODE_ALL_BUT_PACKETS = 2	/**< Decode everything except the JPEG 2000 packets */
+} OPJ_LIMIT_DECODING;
+
+/* 
+==========================================================
+   event manager typedef definitions
+==========================================================
+*/
+
+/**
+Callback function prototype for events
+@param msg Event message
+@param client_data 
+*/
+typedef void (*opj_msg_callback) (const char *msg, void *client_data);
+
+/**
+Message handler object
+used for 
+<ul>
+<li>Error messages
+<li>Warning messages
+<li>Debugging messages
+</ul>
+*/
+typedef struct opj_event_mgr {
+	/** Error message callback if available, NULL otherwise */
+	opj_msg_callback error_handler;
+	/** Warning message callback if available, NULL otherwise */
+	opj_msg_callback warning_handler;
+	/** Debug message callback if available, NULL otherwise */
+	opj_msg_callback info_handler;
+} opj_event_mgr_t;
+
+
+/* 
+==========================================================
+   codec typedef definitions
+==========================================================
+*/
+
+/**
+Progression order changes
+*/
+typedef struct opj_poc {
+	/** Resolution num start, Component num start, given by POC */
+	int resno0, compno0;
+	/** Layer num end,Resolution num end, Component num end, given by POC */
+	int layno1, resno1, compno1;
+	/** Layer num start,Precinct num start, Precinct num end */
+	int layno0, precno0, precno1;
+	/** Progression order enum*/
+	OPJ_PROG_ORDER prg1,prg;
+	/** Progression order string*/
+	char progorder[5];
+	/** Tile number */
+	int tile;
+	/** Start and end values for Tile width and height*/
+	int tx0,tx1,ty0,ty1;
+	/** Start value, initialised in pi_initialise_encode*/
+	int layS, resS, compS, prcS;
+	/** End value, initialised in pi_initialise_encode */
+	int layE, resE, compE, prcE;
+	/** Start and end values of Tile width and height, initialised in pi_initialise_encode*/
+	int txS,txE,tyS,tyE,dx,dy;
+	/** Temporary values for Tile parts, initialised in pi_create_encode */
+	int lay_t, res_t, comp_t, prc_t,tx0_t,ty0_t;
+} opj_poc_t;
+
+/**
+Compression parameters
+*/
+typedef struct opj_cparameters {
+	/** size of tile: tile_size_on = false (not in argument) or = true (in argument) */
+	opj_bool tile_size_on;
+	/** XTOsiz */
+	int cp_tx0;
+	/** YTOsiz */
+	int cp_ty0;
+	/** XTsiz */
+	int cp_tdx;
+	/** YTsiz */
+	int cp_tdy;
+	/** allocation by rate/distortion */
+	int cp_disto_alloc;
+	/** allocation by fixed layer */
+	int cp_fixed_alloc;
+	/** add fixed_quality */
+	int cp_fixed_quality;
+	/** fixed layer */
+	int *cp_matrice;
+	/** comment for coding */
+	char *cp_comment;
+	/** csty : coding style */
+	int csty;
+	/** progression order (default LRCP) */
+	OPJ_PROG_ORDER prog_order;
+	/** progression order changes */
+	opj_poc_t POC[32];
+	/** number of progression order changes (POC), default to 0 */
+	int numpocs;
+	/** number of layers */
+	int tcp_numlayers;
+	/** rates of layers */
+	float tcp_rates[100];
+	/** different psnr for successive layers */
+	float tcp_distoratio[100];
+	/** number of resolutions */
+	int numresolution;
+	/** initial code block width, default to 64 */
+ 	int cblockw_init;
+	/** initial code block height, default to 64 */
+	int cblockh_init;
+	/** mode switch (cblk_style) */
+	int mode;
+	/** 1 : use the irreversible DWT 9-7, 0 : use lossless compression (default) */
+	int irreversible;
+	/** region of interest: affected component in [0..3], -1 means no ROI */
+	int roi_compno;
+	/** region of interest: upshift value */
+	int roi_shift;
+	/* number of precinct size specifications */
+	int res_spec;
+	/** initial precinct width */
+	int prcw_init[J2K_MAXRLVLS];
+	/** initial precinct height */
+	int prch_init[J2K_MAXRLVLS];
+
+	/**@name command line encoder parameters (not used inside the library) */
+	/*@{*/
+	/** input file name */
+	char infile[OPJ_PATH_LEN];
+	/** output file name */
+	char outfile[OPJ_PATH_LEN];
+	/** DEPRECATED. Index generation is now handeld with the opj_encode_with_info() function. Set to NULL */
+	int index_on;
+	/** DEPRECATED. Index generation is now handeld with the opj_encode_with_info() function. Set to NULL */
+	char index[OPJ_PATH_LEN];
+	/** subimage encoding: origin image offset in x direction */
+	int image_offset_x0;
+	/** subimage encoding: origin image offset in y direction */
+	int image_offset_y0;
+	/** subsampling value for dx */
+	int subsampling_dx;
+	/** subsampling value for dy */
+	int subsampling_dy;
+	/** input file format 0: PGX, 1: PxM, 2: BMP 3:TIF*/
+	int decod_format;
+	/** output file format 0: J2K, 1: JP2, 2: JPT */
+	int cod_format;
+	/*@}*/
+
+/* UniPG>> */
+	/**@name JPWL encoding parameters */
+	/*@{*/
+	/** enables writing of EPC in MH, thus activating JPWL */
+	opj_bool jpwl_epc_on;
+	/** error protection method for MH (0,1,16,32,37-128) */
+	int jpwl_hprot_MH;
+	/** tile number of header protection specification (>=0) */
+	int jpwl_hprot_TPH_tileno[JPWL_MAX_NO_TILESPECS];
+	/** error protection methods for TPHs (0,1,16,32,37-128) */
+	int jpwl_hprot_TPH[JPWL_MAX_NO_TILESPECS];
+	/** tile number of packet protection specification (>=0) */
+	int jpwl_pprot_tileno[JPWL_MAX_NO_PACKSPECS];
+	/** packet number of packet protection specification (>=0) */
+	int jpwl_pprot_packno[JPWL_MAX_NO_PACKSPECS];
+	/** error protection methods for packets (0,1,16,32,37-128) */
+	int jpwl_pprot[JPWL_MAX_NO_PACKSPECS];
+	/** enables writing of ESD, (0=no/1/2 bytes) */
+	int jpwl_sens_size;
+	/** sensitivity addressing size (0=auto/2/4 bytes) */
+	int jpwl_sens_addr;
+	/** sensitivity range (0-3) */
+	int jpwl_sens_range;
+	/** sensitivity method for MH (-1=no,0-7) */
+	int jpwl_sens_MH;
+	/** tile number of sensitivity specification (>=0) */
+	int jpwl_sens_TPH_tileno[JPWL_MAX_NO_TILESPECS];
+	/** sensitivity methods for TPHs (-1=no,0-7) */
+	int jpwl_sens_TPH[JPWL_MAX_NO_TILESPECS];
+	/*@}*/
+/* <<UniPG */
+
+	/** Digital Cinema compliance 0-not compliant, 1-compliant*/
+	OPJ_CINEMA_MODE cp_cinema;
+	/** Maximum rate for each component. If == 0, component size limitation is not considered */
+	int max_comp_size;
+	/** Profile name*/
+	OPJ_RSIZ_CAPABILITIES cp_rsiz;
+	/** Tile part generation*/
+	char tp_on;
+	/** Flag for Tile part generation*/
+	char tp_flag;
+	/** MCT (multiple component transform) */
+	char tcp_mct;
+	/** Enable JPIP indexing*/
+	opj_bool jpip_on;
+} opj_cparameters_t;
+
+#define OPJ_DPARAMETERS_IGNORE_PCLR_CMAP_CDEF_FLAG	0x0001
+
+/**
+Decompression parameters
+*/
+typedef struct opj_dparameters {
+	/** 
+	Set the number of highest resolution levels to be discarded. 
+	The image resolution is effectively divided by 2 to the power of the number of discarded levels. 
+	The reduce factor is limited by the smallest total number of decomposition levels among tiles.
+	if != 0, then original dimension divided by 2^(reduce); 
+	if == 0 or not used, image is decoded to the full resolution 
+	*/
+	int cp_reduce;
+	/** 
+	Set the maximum number of quality layers to decode. 
+	If there are less quality layers than the specified number, all the quality layers are decoded.
+	if != 0, then only the first "layer" layers are decoded; 
+	if == 0 or not used, all the quality layers are decoded 
+	*/
+	int cp_layer;
+
+	/**@name command line encoder parameters (not used inside the library) */
+	/*@{*/
+	/** input file name */
+	char infile[OPJ_PATH_LEN];
+	/** output file name */
+	char outfile[OPJ_PATH_LEN];
+	/** input file format 0: J2K, 1: JP2, 2: JPT */
+	int decod_format;
+	/** output file format 0: PGX, 1: PxM, 2: BMP */
+	int cod_format;
+	/*@}*/
+
+/* UniPG>> */
+	/**@name JPWL decoding parameters */
+	/*@{*/
+	/** activates the JPWL correction capabilities */
+	opj_bool jpwl_correct;
+	/** expected number of components */
+	int jpwl_exp_comps;
+	/** maximum number of tiles */
+	int jpwl_max_tiles;
+	/*@}*/
+/* <<UniPG */
+
+	/** 
+	Specify whether the decoding should be done on the entire codestream, or be limited to the main header
+	Limiting the decoding to the main header makes it possible to extract the characteristics of the codestream
+	if == NO_LIMITATION, the entire codestream is decoded; 
+	if == LIMIT_TO_MAIN_HEADER, only the main header is decoded; 
+	*/
+	OPJ_LIMIT_DECODING cp_limit_decoding;
+
+	unsigned int flags;
+} opj_dparameters_t;
+
+/** Common fields between JPEG-2000 compression and decompression master structs. */
+
+#define opj_common_fields \
+	opj_event_mgr_t *event_mgr;	/**< pointer to the event manager */\
+	void * client_data;			/**< Available for use by application */\
+	opj_bool is_decompressor;	/**< So common code can tell which is which */\
+	OPJ_CODEC_FORMAT codec_format;	/**< selected codec */\
+	void *j2k_handle;			/**< pointer to the J2K codec */\
+	void *jp2_handle;			/**< pointer to the JP2 codec */\
+	void *mj2_handle			/**< pointer to the MJ2 codec */
+	
+/* Routines that are to be used by both halves of the library are declared
+ * to receive a pointer to this structure.  There are no actual instances of
+ * opj_common_struct_t, only of opj_cinfo_t and opj_dinfo_t.
+ */
+typedef struct opj_common_struct {
+  opj_common_fields;		/* Fields common to both master struct types */
+  /* Additional fields follow in an actual opj_cinfo_t or
+   * opj_dinfo_t.  All three structs must agree on these
+   * initial fields!  (This would be a lot cleaner in C++.)
+   */
+} opj_common_struct_t;
+
+typedef opj_common_struct_t * opj_common_ptr;
+
+/**
+Compression context info
+*/
+typedef struct opj_cinfo {
+	/** Fields shared with opj_dinfo_t */
+	opj_common_fields;	
+	/* other specific fields go here */
+} opj_cinfo_t;
+
+/**
+Decompression context info
+*/
+typedef struct opj_dinfo {
+	/** Fields shared with opj_cinfo_t */
+	opj_common_fields;	
+	/* other specific fields go here */
+} opj_dinfo_t;
+
+/* 
+==========================================================
+   I/O stream typedef definitions
+==========================================================
+*/
+
+/*
+ * Stream open flags.
+ */
+/** The stream was opened for reading. */
+#define OPJ_STREAM_READ	0x0001
+/** The stream was opened for writing. */
+#define OPJ_STREAM_WRITE 0x0002
+
+/**
+Byte input-output stream (CIO)
+*/
+typedef struct opj_cio {
+	/** codec context */
+	opj_common_ptr cinfo;
+
+	/** open mode (read/write) either OPJ_STREAM_READ or OPJ_STREAM_WRITE */
+	int openmode;
+	/** pointer to the start of the buffer */
+	unsigned char *buffer;
+	/** buffer size in bytes */
+	int length;
+
+	/** pointer to the start of the stream */
+	unsigned char *start;
+	/** pointer to the end of the stream */
+	unsigned char *end;
+	/** pointer to the current position */
+	unsigned char *bp;
+} opj_cio_t;
+
+/* 
+==========================================================
+   image typedef definitions
+==========================================================
+*/
+
+/**
+Defines a single image component
+*/
+typedef struct opj_image_comp {
+	/** XRsiz: horizontal separation of a sample of ith component with respect to the reference grid */
+	int dx;
+	/** YRsiz: vertical separation of a sample of ith component with respect to the reference grid */
+	int dy;
+	/** data width */
+	int w;
+	/** data height */
+	int h;
+	/** x component offset compared to the whole image */
+	int x0;
+	/** y component offset compared to the whole image */
+	int y0;
+	/** precision */
+	int prec;
+	/** image depth in bits */
+	int bpp;
+	/** signed (1) / unsigned (0) */
+	int sgnd;
+	/** number of decoded resolution */
+	int resno_decoded;
+	/** number of division by 2 of the out image compared to the original size of image */
+	int factor;
+	/** image component data */
+	int *data;
+} opj_image_comp_t;
+
+/** 
+Defines image data and characteristics
+*/
+typedef struct opj_image {
+	/** XOsiz: horizontal offset from the origin of the reference grid to the left side of the image area */
+	int x0;
+	/** YOsiz: vertical offset from the origin of the reference grid to the top side of the image area */
+	int y0;
+	/** Xsiz: width of the reference grid */
+	int x1;
+	/** Ysiz: height of the reference grid */
+	int y1;
+	/** number of components in the image */
+	int numcomps;
+	/** color space: sRGB, Greyscale or YUV */
+	OPJ_COLOR_SPACE color_space;
+	/** image components */
+	opj_image_comp_t *comps;
+	/** 'restricted' ICC profile */
+	unsigned char *icc_profile_buf;
+	/** size of ICC profile */
+	int icc_profile_len;
+} opj_image_t;
+
+/**
+Component parameters structure used by the opj_image_create function
+*/
+typedef struct opj_image_comptparm {
+	/** XRsiz: horizontal separation of a sample of ith component with respect to the reference grid */
+	int dx;
+	/** YRsiz: vertical separation of a sample of ith component with respect to the reference grid */
+	int dy;
+	/** data width */
+	int w;
+	/** data height */
+	int h;
+	/** x component offset compared to the whole image */
+	int x0;
+	/** y component offset compared to the whole image */
+	int y0;
+	/** precision */
+	int prec;
+	/** image depth in bits */
+	int bpp;
+	/** signed (1) / unsigned (0) */
+	int sgnd;
+} opj_image_cmptparm_t;
+
+/* 
+==========================================================
+   Information on the JPEG 2000 codestream
+==========================================================
+*/
+
+/**
+Index structure : Information concerning a packet inside tile
+*/
+typedef struct opj_packet_info {
+	/** packet start position (including SOP marker if it exists) */
+	int start_pos;
+	/** end of packet header position (including EPH marker if it exists)*/
+	int end_ph_pos;
+	/** packet end position */
+	int end_pos;
+	/** packet distorsion */
+	double disto;
+} opj_packet_info_t;
+
+
+/* UniPG>> */
+/**
+Marker structure
+*/
+typedef struct opj_marker_info_t {
+	/** marker type */
+	unsigned short int type;
+	/** position in codestream */
+	int pos;
+	/** length, marker val included */
+	int len;
+} opj_marker_info_t;
+/* <<UniPG */
+
+/**
+Index structure : Information concerning tile-parts
+*/
+typedef struct opj_tp_info {
+	/** start position of tile part */
+	int tp_start_pos;
+	/** end position of tile part header */
+	int tp_end_header;
+	/** end position of tile part */
+	int tp_end_pos;
+	/** start packet of tile part */
+	int tp_start_pack;
+	/** number of packets of tile part */
+	int tp_numpacks;
+} opj_tp_info_t;
+
+/**
+Index structure : information regarding tiles 
+*/
+typedef struct opj_tile_info {
+	/** value of thresh for each layer by tile cfr. Marcela   */
+	double *thresh;
+	/** number of tile */
+	int tileno;
+	/** start position */
+	int start_pos;
+	/** end position of the header */
+	int end_header;
+	/** end position */
+	int end_pos;
+	/** precinct number for each resolution level (width) */
+	int pw[33];
+	/** precinct number for each resolution level (height) */
+	int ph[33];
+	/** precinct size (in power of 2), in X for each resolution level */
+	int pdx[33];
+	/** precinct size (in power of 2), in Y for each resolution level */
+	int pdy[33];
+	/** information concerning packets inside tile */
+	opj_packet_info_t *packet;
+	/** add fixed_quality */
+	int numpix;
+	/** add fixed_quality */
+	double distotile;
+  	/** number of markers */
+	int marknum;
+	/** list of markers */
+	opj_marker_info_t *marker;
+	/** actual size of markers array */
+	int maxmarknum;
+	/** number of tile parts */
+	int num_tps;
+	/** information concerning tile parts */
+	opj_tp_info_t *tp;
+} opj_tile_info_t;
+
+/**
+Index structure of the codestream
+*/
+typedef struct opj_codestream_info {
+	/** maximum distortion reduction on the whole image (add for Marcela) */
+	double D_max;
+	/** packet number */
+	int packno;
+	/** writing the packet in the index with t2_encode_packets */
+	int index_write;
+	/** image width */
+	int image_w;
+	/** image height */
+	int image_h;
+	/** progression order */
+	OPJ_PROG_ORDER prog;
+	/** tile size in x */
+	int tile_x;
+	/** tile size in y */
+	int tile_y;
+	/** */
+	int tile_Ox;
+	/** */
+	int tile_Oy;
+	/** number of tiles in X */
+	int tw;
+	/** number of tiles in Y */
+	int th;
+	/** component numbers */
+	int numcomps;
+	/** number of layer */
+	int numlayers;
+	/** number of decomposition for each component */
+	int *numdecompos;
+/* UniPG>> */
+	/** number of markers */
+	int marknum;
+	/** list of markers */
+	opj_marker_info_t *marker;
+	/** actual size of markers array */
+	int maxmarknum;
+/* <<UniPG */
+	/** main header position */
+	int main_head_start;
+	/** main header position */
+	int main_head_end;
+	/** codestream's size */
+	int codestream_size;
+	/** information regarding tiles inside image */
+	opj_tile_info_t *tile;
+} opj_codestream_info_t;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/* 
+==========================================================
+   openjpeg version
+==========================================================
+*/
+
+OPJ_API const char * OPJ_CALLCONV opj_version(void);
+
+/* 
+==========================================================
+   image functions definitions
+==========================================================
+*/
+
+/**
+Create an image
+@param numcmpts number of components
+@param cmptparms components parameters
+@param clrspc image color space
+@return returns a new image structure if successful, returns NULL otherwise
+*/
+OPJ_API opj_image_t* OPJ_CALLCONV opj_image_create(int numcmpts, opj_image_cmptparm_t *cmptparms, OPJ_COLOR_SPACE clrspc);
+
+/**
+Deallocate any resources associated with an image
+@param image image to be destroyed
+*/
+OPJ_API void OPJ_CALLCONV opj_image_destroy(opj_image_t *image);
+
+/* 
+==========================================================
+   stream functions definitions
+==========================================================
+*/
+
+/**
+Open and allocate a memory stream for read / write. 
+On reading, the user must provide a buffer containing encoded data. The buffer will be 
+wrapped by the returned CIO handle. 
+On writing, buffer parameters must be set to 0: a buffer will be allocated by the library 
+to contain encoded data. 
+@param cinfo Codec context info
+@param buffer Reading: buffer address. Writing: NULL
+@param length Reading: buffer length. Writing: 0
+@return Returns a CIO handle if successful, returns NULL otherwise
+*/
+OPJ_API opj_cio_t* OPJ_CALLCONV opj_cio_open(opj_common_ptr cinfo, unsigned char *buffer, int length);
+
+/**
+Close and free a CIO handle
+@param cio CIO handle to free
+*/
+OPJ_API void OPJ_CALLCONV opj_cio_close(opj_cio_t *cio);
+
+/**
+Get position in byte stream
+@param cio CIO handle
+@return Returns the position in bytes
+*/
+OPJ_API int OPJ_CALLCONV cio_tell(opj_cio_t *cio);
+/**
+Set position in byte stream
+@param cio CIO handle
+@param pos Position, in number of bytes, from the beginning of the stream
+*/
+OPJ_API void OPJ_CALLCONV cio_seek(opj_cio_t *cio, int pos);
+
+/* 
+==========================================================
+   event manager functions definitions
+==========================================================
+*/
+
+OPJ_API opj_event_mgr_t* OPJ_CALLCONV opj_set_event_mgr(opj_common_ptr cinfo, opj_event_mgr_t *event_mgr, void *context);
+
+/* 
+==========================================================
+   codec functions definitions
+==========================================================
+*/
+/**
+Creates a J2K/JPT/JP2 decompression structure
+@param format Decoder to select
+@return Returns a handle to a decompressor if successful, returns NULL otherwise
+*/
+OPJ_API opj_dinfo_t* OPJ_CALLCONV opj_create_decompress(OPJ_CODEC_FORMAT format);
+/**
+Destroy a decompressor handle
+@param dinfo decompressor handle to destroy
+*/
+OPJ_API void OPJ_CALLCONV opj_destroy_decompress(opj_dinfo_t *dinfo);
+/**
+Set decoding parameters to default values
+@param parameters Decompression parameters
+*/
+OPJ_API void OPJ_CALLCONV opj_set_default_decoder_parameters(opj_dparameters_t *parameters);
+/**
+Setup the decoder decoding parameters using user parameters.
+Decoding parameters are returned in j2k->cp. 
+@param dinfo decompressor handle
+@param parameters decompression parameters
+*/
+OPJ_API void OPJ_CALLCONV opj_setup_decoder(opj_dinfo_t *dinfo, opj_dparameters_t *parameters);
+/**
+Decode an image from a JPEG-2000 codestream 
+@param dinfo decompressor handle
+@param cio Input buffer stream
+@return Returns a decoded image if successful, returns NULL otherwise
+*/
+OPJ_API opj_image_t* OPJ_CALLCONV opj_decode(opj_dinfo_t *dinfo, opj_cio_t *cio);
+
+/**
+Decode an image from a JPEG-2000 codestream and extract the codestream information
+@param dinfo decompressor handle
+@param cio Input buffer stream
+@param cstr_info Codestream information structure if needed afterwards, NULL otherwise
+@return Returns a decoded image if successful, returns NULL otherwise
+*/
+OPJ_API opj_image_t* OPJ_CALLCONV opj_decode_with_info(opj_dinfo_t *dinfo, opj_cio_t *cio, opj_codestream_info_t *cstr_info);
+/**
+Creates a J2K/JP2 compression structure
+@param format Coder to select
+@return Returns a handle to a compressor if successful, returns NULL otherwise
+*/
+OPJ_API opj_cinfo_t* OPJ_CALLCONV opj_create_compress(OPJ_CODEC_FORMAT format);
+/**
+Destroy a compressor handle
+@param cinfo compressor handle to destroy
+*/
+OPJ_API void OPJ_CALLCONV opj_destroy_compress(opj_cinfo_t *cinfo);
+/**
+Set encoding parameters to default values, that means : 
+<ul>
+<li>Lossless
+<li>1 tile
+<li>Size of precinct : 2^15 x 2^15 (means 1 precinct)
+<li>Size of code-block : 64 x 64
+<li>Number of resolutions: 6
+<li>No SOP marker in the codestream
+<li>No EPH marker in the codestream
+<li>No sub-sampling in x or y direction
+<li>No mode switch activated
+<li>Progression order: LRCP
+<li>No index file
+<li>No ROI upshifted
+<li>No offset of the origin of the image
+<li>No offset of the origin of the tiles
+<li>Reversible DWT 5-3
+</ul>
+@param parameters Compression parameters
+*/
+OPJ_API void OPJ_CALLCONV opj_set_default_encoder_parameters(opj_cparameters_t *parameters);
+/**
+Setup the encoder parameters using the current image and using user parameters. 
+@param cinfo Compressor handle
+@param parameters Compression parameters
+@param image Input filled image
+*/
+OPJ_API void OPJ_CALLCONV opj_setup_encoder(opj_cinfo_t *cinfo, opj_cparameters_t *parameters, opj_image_t *image);
+/**
+Encode an image into a JPEG-2000 codestream
+3@param cinfo compressor handle
+@param cio Output buffer stream
+@param image Image to encode
+@param index Depreacted -> Set to NULL. To extract index, used opj_encode_wci()
+@return Returns true if successful, returns false otherwise
+*/
+OPJ_API opj_bool OPJ_CALLCONV opj_encode(opj_cinfo_t *cinfo, opj_cio_t *cio, opj_image_t *image, char *index);
+/**
+Encode an image into a JPEG-2000 codestream and extract the codestream information
+@param cinfo compressor handle
+@param cio Output buffer stream
+@param image Image to encode
+@param cstr_info Codestream information structure if needed afterwards, NULL otherwise
+@return Returns true if successful, returns false otherwise
+*/
+OPJ_API opj_bool OPJ_CALLCONV opj_encode_with_info(opj_cinfo_t *cinfo, opj_cio_t *cio, opj_image_t *image, opj_codestream_info_t *cstr_info);
+/**
+Destroy Codestream information after compression or decompression
+@param cstr_info Codestream information structure
+*/
+OPJ_API void OPJ_CALLCONV opj_destroy_cstr_info(opj_codestream_info_t *cstr_info);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* OPENJPEG_H */

src/add-ons/translators/icns/openjpeg/opj_config.h

@@ -0,0 +1,117 @@
+/* opj_config.h.  Generated from opj_config.h.in by configure.  */
+/* opj_config.h.in.  Generated from configure.ac by autoheader.  */
+
+/* Define if building universal (internal helper macro) */
+/* #undef AC_APPLE_UNIVERSAL_BUILD */
+
+/* Define to 1 if you have the <dirent.h> header file, and it defines `DIR'.
+   */
+#define HAVE_DIRENT_H 1
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#define HAVE_DLFCN_H 1
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#define HAVE_INTTYPES_H 1
+
+/* define to 1 if you have lcms version 1.x */
+/* #undef HAVE_LIBLCMS1 */
+
+/* define to 1 if you have lcms version 2.x */
+/* #undef HAVE_LIBLCMS2 */
+
+/* define to 1 if you have libpng */
+#define HAVE_LIBPNG 1
+
+/* define to 1 if you have libtiff */
+#define HAVE_LIBTIFF 1
+
+/* Define to 1 if you have the <memory.h> header file. */
+#define HAVE_MEMORY_H 1
+
+/* Define to 1 if you have the <ndir.h> header file, and it defines `DIR'. */
+/* #undef HAVE_NDIR_H */
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#define HAVE_STDINT_H 1
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#define HAVE_STDLIB_H 1
+
+/* Define to 1 if you have the <strings.h> header file. */
+#define HAVE_STRINGS_H 1
+
+/* Define to 1 if you have the <string.h> header file. */
+#define HAVE_STRING_H 1
+
+/* Define to 1 if you have the <sys/dir.h> header file, and it defines `DIR'.
+   */
+/* #undef HAVE_SYS_DIR_H */
+
+/* Define to 1 if you have the <sys/ndir.h> header file, and it defines `DIR'.
+   */
+/* #undef HAVE_SYS_NDIR_H */
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#define HAVE_SYS_STAT_H 1
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#define HAVE_SYS_TYPES_H 1
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#define HAVE_UNISTD_H 1
+
+/* Define to the sub-directory in which libtool stores uninstalled libraries.
+   */
+#define LT_OBJDIR ".libs/"
+
+/* Define to 1 if your C compiler doesn't accept -c and -o together. */
+/* #undef NO_MINUS_C_MINUS_O */
+
+/* Name of package */
+#define PACKAGE "openjpeg"
+
+/* Define to the address where bug reports for this package should be sent. */
+#define PACKAGE_BUGREPORT "[email protected]"
+
+/* Define to the full name of this package. */
+#define PACKAGE_NAME "OpenJPEG"
+
+/* Define to the full name and version of this package. */
+#define PACKAGE_STRING "OpenJPEG 1.5.0"
+
+/* Define to the one symbol short name of this package. */
+#define PACKAGE_TARNAME "openjpeg"
+
+/* Define to the home page for this package. */
+#define PACKAGE_URL "http://www.openjpeg.org"
+
+/* Define to the version of this package. */
+#define PACKAGE_VERSION "1.5.1"
+
+/* Define to 1 if you have the ANSI C header files. */
+#define STDC_HEADERS 1
+
+/* define to 1 if you use jpip */
+/* #undef USE_JPIP */
+
+/* define to 1 if you use jpip server */
+/* #undef USE_JPIP_SERVER */
+
+/* define to 1 if you use mj2 */
+/* #undef USE_MJ2 */
+
+/* Version number of package */
+#define VERSION "1.5.1"
+
+/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
+   significant byte first (like Motorola and SPARC, unlike Intel). */
+#if defined AC_APPLE_UNIVERSAL_BUILD
+# if defined __BIG_ENDIAN__
+#  define WORDS_BIGENDIAN 1
+# endif
+#else
+# ifndef WORDS_BIGENDIAN
+/* #  undef WORDS_BIGENDIAN */
+# endif
+#endif

src/add-ons/translators/icns/openjpeg/opj_includes.h

@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef OPJ_INCLUDES_H
+#define OPJ_INCLUDES_H
+
+/*
+ ==========================================================
+   Standard includes used by the library
+ ==========================================================
+*/
+#include <memory.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <float.h>
+#include <time.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <ctype.h>
+
+/*
+ ==========================================================
+   OpenJPEG interface
+ ==========================================================
+ */
+#include "openjpeg.h"
+
+/*
+ ==========================================================
+   OpenJPEG modules
+ ==========================================================
+*/
+
+/* Ignore GCC attributes if this is not GCC */
+#ifndef __GNUC__
+	#define __attribute__(x) /* __attribute__(x) */
+#endif
+
+/*
+The inline keyword is supported by C99 but not by C90. 
+Most compilers implement their own version of this keyword ... 
+*/
+#ifndef INLINE
+	#if defined(_MSC_VER)
+		#define INLINE __forceinline
+	#elif defined(__GNUC__)
+		#define INLINE __inline__
+	#elif defined(__MWERKS__)
+		#define INLINE inline
+	#else 
+		/* add other compilers here ... */
+		#define INLINE 
+	#endif /* defined(<Compiler>) */
+#endif /* INLINE */
+
+/* Are restricted pointers available? (C99) */
+#if (__STDC_VERSION__ != 199901L)
+	/* Not a C99 compiler */
+	#ifdef __GNUC__
+		#define restrict __restrict__
+	#else
+		#define restrict /* restrict */
+	#endif
+#endif
+
+/* MSVC and Borland C do not have lrintf */
+#if defined(_MSC_VER) || defined(__BORLANDC__)
+static INLINE long lrintf(float f){
+#ifdef _M_X64
+    return (long)((f>0.0f) ? (f + 0.5f):(f -0.5f));
+#else
+    int i;
+ 
+    _asm{
+        fld f
+        fistp i
+    };
+ 
+    return i;
+#endif
+}
+#endif
+
+#include "j2k_lib.h"
+#include "opj_malloc.h"
+#include "event.h"
+#include "bio.h"
+#include "cio.h"
+
+#include "oj_image.h"
+#include "j2k.h"
+#include "jp2.h"
+#include "jpt.h"
+
+#include "mqc.h"
+#include "raw.h"
+#include "bio.h"
+#include "tgt.h"
+#include "pi.h"
+#include "tcd.h"
+#include "t1.h"
+#include "dwt.h"
+#include "t2.h"
+#include "mct.h"
+#include "int.h"
+#include "fix.h"
+
+#include "cidx_manager.h"
+#include "indexbox_manager.h"
+
+/* JPWL>> */
+#ifdef USE_JPWL
+#include "./jpwl/jpwl.h"
+#endif /* USE_JPWL */
+/* <<JPWL */
+
+#endif /* OPJ_INCLUDES_H */

src/add-ons/translators/icns/openjpeg/opj_malloc.h

@@ -0,0 +1,165 @@
+/*
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * Copyright (c) 2007, Callum Lerwick <seg@haxxed.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __OPJ_MALLOC_H
+#define __OPJ_MALLOC_H
+/**
+@file opj_malloc.h
+@brief Internal functions
+
+The functions in opj_malloc.h are internal utilities used for memory management.
+*/
+
+/** @defgroup MISC MISC - Miscellaneous internal functions */
+/*@{*/
+
+/** @name Exported functions */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+
+/**
+Allocate an uninitialized memory block
+@param size Bytes to allocate
+@return Returns a void pointer to the allocated space, or NULL if there is insufficient memory available
+*/
+#ifdef ALLOC_PERF_OPT
+void * OPJ_CALLCONV opj_malloc(size_t size);
+#else
+#define opj_malloc(size) malloc(size)
+#endif
+
+/**
+Allocate a memory block with elements initialized to 0
+@param num Blocks to allocate
+@param size Bytes per block to allocate
+@return Returns a void pointer to the allocated space, or NULL if there is insufficient memory available
+*/
+#ifdef ALLOC_PERF_OPT
+void * OPJ_CALLCONV opj_calloc(size_t _NumOfElements, size_t _SizeOfElements);
+#else
+#define opj_calloc(num, size) calloc(num, size)
+#endif
+
+/**
+Allocate memory aligned to a 16 byte boundry
+@param size Bytes to allocate
+@return Returns a void pointer to the allocated space, or NULL if there is insufficient memory available
+*/
+/* FIXME: These should be set with cmake tests, but we're currently not requiring use of cmake */
+#ifdef _WIN32
+	/* Someone should tell the mingw people that their malloc.h ought to provide _mm_malloc() */
+	#ifdef __GNUC__
+		#include <mm_malloc.h>
+		#define HAVE_MM_MALLOC
+	#else /* MSVC, Intel C++ */
+		#include <malloc.h>
+		#ifdef _mm_malloc
+			#define HAVE_MM_MALLOC
+		#endif
+	#endif
+#else /* Not _WIN32 */
+	#if defined(__sun)
+		#define HAVE_MEMALIGN
+  #elif defined(__FreeBSD__)
+    #define HAVE_POSIX_MEMALIGN
+	/* Linux x86_64 and OSX always align allocations to 16 bytes */
+	#elif !defined(__amd64__) && !defined(__APPLE__) && !defined(_AIX)
+		#define HAVE_MEMALIGN
+		#include <malloc.h>			
+	#endif
+#endif
+
+#define opj_aligned_malloc(size) malloc(size)
+#define opj_aligned_free(m) free(m)
+
+#ifdef HAVE_MM_MALLOC
+	#undef opj_aligned_malloc
+	#define opj_aligned_malloc(size) _mm_malloc(size, 16)
+	#undef opj_aligned_free
+	#define opj_aligned_free(m) _mm_free(m)
+#endif
+
+#ifdef HAVE_MEMALIGN
+	extern void* memalign(size_t, size_t);
+	#undef opj_aligned_malloc
+	#define opj_aligned_malloc(size) memalign(16, (size))
+	#undef opj_aligned_free
+	#define opj_aligned_free(m) free(m)
+#endif
+
+#ifdef HAVE_POSIX_MEMALIGN
+	#undef opj_aligned_malloc
+	extern int posix_memalign(void**, size_t, size_t);
+
+	static INLINE void* __attribute__ ((malloc)) opj_aligned_malloc(size_t size){
+		void* mem = NULL;
+		posix_memalign(&mem, 16, size);
+		return mem;
+	}
+	#undef opj_aligned_free
+	#define opj_aligned_free(m) free(m)
+#endif
+
+#ifdef ALLOC_PERF_OPT
+	#undef opj_aligned_malloc
+	#define opj_aligned_malloc(size) opj_malloc(size)
+	#undef opj_aligned_free
+	#define opj_aligned_free(m) opj_free(m)
+#endif
+
+/**
+Reallocate memory blocks.
+@param m Pointer to previously allocated memory block
+@param s New size in bytes
+@return Returns a void pointer to the reallocated (and possibly moved) memory block
+*/
+#ifdef ALLOC_PERF_OPT
+void * OPJ_CALLCONV opj_realloc(void * m, size_t s);
+#else
+#define opj_realloc(m, s) realloc(m, s)
+#endif
+
+/**
+Deallocates or frees a memory block.
+@param m Previously allocated memory block to be freed
+*/
+#ifdef ALLOC_PERF_OPT
+void OPJ_CALLCONV opj_free(void * m);
+#else
+#define opj_free(m) free(m)
+#endif
+
+#ifdef __GNUC__
+#pragma GCC poison malloc calloc realloc free
+#endif
+
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __OPJ_MALLOC_H */
+

src/add-ons/translators/icns/openjpeg/phix_manager.c

@@ -0,0 +1,170 @@
+/*
+ * $Id: phix_manager.c 897 2011-08-28 21:43:57Z Kaori.Hagihara@gmail.com $
+ *
+ * Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2011, Professor Benoit Macq
+ * Copyright (c) 2003-2004, Yannick Verschueren
+ * Copyright (c) 2010-2011, Kaori Hagihara
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*! \file
+ *  \brief Modification of jpip.c from 2KAN indexer
+ */
+
+#include <stdlib.h>
+#include <math.h>
+#include "opj_includes.h"
+
+/* 
+ * Write faix box of phix
+ *
+ * @param[in] coff      offset of j2k codestream
+ * @param[in] compno    component number
+ * @param[in] cstr_info codestream information
+ * @param[in] EPHused   true if if EPH option used
+ * @param[in] j2klen    length of j2k codestream
+ * @param[in] cio       file output handle
+ * @return              length of faix box
+ */
+int write_phixfaix( int coff, int compno, opj_codestream_info_t cstr_info, opj_bool EPHused, int j2klen, opj_cio_t *cio);
+
+int write_phix( int coff, opj_codestream_info_t cstr_info, opj_bool EPHused, int j2klen, opj_cio_t *cio)
+{
+  int len, lenp=0, compno, i;
+  opj_jp2_box_t *box;
+
+  box = (opj_jp2_box_t *)opj_calloc( cstr_info.numcomps, sizeof(opj_jp2_box_t));
+  
+  for( i=0;i<2;i++){
+    if (i) cio_seek( cio, lenp);
+      
+    lenp = cio_tell( cio);
+    cio_skip( cio, 4);              /* L [at the end] */
+    cio_write( cio, JPIP_PHIX, 4);  /* PHIX           */
+      
+    write_manf( i, cstr_info.numcomps, box, cio);
+
+    for( compno=0; compno<cstr_info.numcomps; compno++){       
+      box[compno].length = write_phixfaix( coff, compno, cstr_info, EPHused, j2klen, cio);
+      box[compno].type = JPIP_FAIX;
+    }
+
+    len = cio_tell( cio)-lenp;
+    cio_seek( cio, lenp);
+    cio_write( cio, len, 4);        /* L              */
+    cio_seek( cio, lenp+len);
+  }
+
+  opj_free(box);
+
+  return len;
+}
+
+int write_phixfaix( int coff, int compno, opj_codestream_info_t cstr_info, opj_bool EPHused, int j2klen, opj_cio_t *cio)
+{
+  int len, lenp, tileno, version, i, nmax, size_of_coding; /* 4 or 8 */
+  opj_tile_info_t *tile_Idx;
+  opj_packet_info_t packet;
+  int resno, precno, layno, num_packet;
+  int numOfres, numOfprec, numOflayers;
+  packet.end_ph_pos = packet.start_pos = -1;
+  (void)EPHused; /* unused ? */
+
+  if( j2klen > pow( 2, 32)){
+    size_of_coding =  8;
+    version = 1;
+  }
+  else{
+    size_of_coding = 4;
+    version = 0;
+  }
+
+  lenp = cio_tell( cio);
+  cio_skip( cio, 4);              /* L [at the end]      */
+  cio_write( cio, JPIP_FAIX, 4);  /* FAIX                */ 
+  cio_write( cio, version,1);     /* Version 0 = 4 bytes */
+
+  nmax = 0;
+  for( i=0; i<=cstr_info.numdecompos[compno]; i++)
+    nmax += cstr_info.tile[0].ph[i] * cstr_info.tile[0].pw[i] * cstr_info.numlayers;
+  
+  cio_write( cio, nmax, size_of_coding); /* NMAX */
+  cio_write( cio, cstr_info.tw*cstr_info.th, size_of_coding);      /* M    */
+  
+  for( tileno=0; tileno<cstr_info.tw*cstr_info.th; tileno++){
+    tile_Idx = &cstr_info.tile[ tileno];
+    
+    num_packet = 0;
+    numOfres = cstr_info.numdecompos[compno] + 1;
+
+    for( resno=0; resno<numOfres ; resno++){
+      numOfprec = tile_Idx->pw[resno]*tile_Idx->ph[resno];
+      for( precno=0; precno<numOfprec; precno++){
+	numOflayers = cstr_info.numlayers;
+	for( layno=0; layno<numOflayers; layno++){
+	  
+	  switch ( cstr_info.prog){
+	  case LRCP:
+	    packet = tile_Idx->packet[ ((layno*numOfres+resno)*cstr_info.numcomps+compno)*numOfprec+precno];
+	    break;
+	  case RLCP:
+	    packet = tile_Idx->packet[ ((resno*numOflayers+layno)*cstr_info.numcomps+compno)*numOfprec+precno];
+	    break;
+	  case RPCL:
+	    packet = tile_Idx->packet[ ((resno*numOfprec+precno)*cstr_info.numcomps+compno)*numOflayers+layno];
+	    break;
+	  case PCRL:
+	    packet = tile_Idx->packet[ ((precno*cstr_info.numcomps+compno)*numOfres+resno)*numOflayers + layno];
+	    break;
+	  case CPRL:
+	    packet = tile_Idx->packet[ ((compno*numOfprec+precno)*numOfres+resno)*numOflayers + layno];
+	    break;
+	  default:
+	    fprintf( stderr, "failed to ppix indexing\n");
+	  }
+
+	  cio_write( cio, packet.start_pos-coff, size_of_coding);                /* start position */
+	  cio_write( cio, packet.end_ph_pos-packet.start_pos+1, size_of_coding); /* length         */
+	  
+	  num_packet++;
+	}
+      }
+    }
+
+    /* PADDING */
+    while( num_packet < nmax){
+      cio_write( cio, 0, size_of_coding); /* start position            */
+      cio_write( cio, 0, size_of_coding); /* length                    */
+      num_packet++;
+    }
+  }
+
+  len = cio_tell( cio)-lenp;
+  cio_seek( cio, lenp);
+  cio_write( cio, len, 4);        /* L  */
+  cio_seek( cio, lenp+len);
+
+  return len;
+}

src/add-ons/translators/icns/openjpeg/pi.c

@@ -0,0 +1,963 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * Copyright (c) 2006-2007, Parvatha Elangovan
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "opj_includes.h"
+
+/** @defgroup PI PI - Implementation of a packet iterator */
+/*@{*/
+
+/** @name Local static functions */
+/*@{*/
+
+/**
+Get next packet in layer-resolution-component-precinct order.
+@param pi packet iterator to modify
+@return returns false if pi pointed to the last packet or else returns true 
+*/
+static opj_bool pi_next_lrcp(opj_pi_iterator_t * pi);
+/**
+Get next packet in resolution-layer-component-precinct order.
+@param pi packet iterator to modify
+@return returns false if pi pointed to the last packet or else returns true 
+*/
+static opj_bool pi_next_rlcp(opj_pi_iterator_t * pi);
+/**
+Get next packet in resolution-precinct-component-layer order.
+@param pi packet iterator to modify
+@return returns false if pi pointed to the last packet or else returns true 
+*/
+static opj_bool pi_next_rpcl(opj_pi_iterator_t * pi);
+/**
+Get next packet in precinct-component-resolution-layer order.
+@param pi packet iterator to modify
+@return returns false if pi pointed to the last packet or else returns true 
+*/
+static opj_bool pi_next_pcrl(opj_pi_iterator_t * pi);
+/**
+Get next packet in component-precinct-resolution-layer order.
+@param pi packet iterator to modify
+@return returns false if pi pointed to the last packet or else returns true 
+*/
+static opj_bool pi_next_cprl(opj_pi_iterator_t * pi);
+
+/*@}*/
+
+/*@}*/
+
+/* 
+==========================================================
+   local functions
+==========================================================
+*/
+
+static opj_bool pi_next_lrcp(opj_pi_iterator_t * pi) {
+	opj_pi_comp_t *comp = NULL;
+	opj_pi_resolution_t *res = NULL;
+	long index = 0;
+	
+	if (!pi->first) {
+		comp = &pi->comps[pi->compno];
+		res = &comp->resolutions[pi->resno];
+		goto LABEL_SKIP;
+	} else {
+		pi->first = 0;
+	}
+
+	for (pi->layno = pi->poc.layno0; pi->layno < pi->poc.layno1; pi->layno++) {
+		for (pi->resno = pi->poc.resno0; pi->resno < pi->poc.resno1;
+		pi->resno++) {
+			for (pi->compno = pi->poc.compno0; pi->compno < pi->poc.compno1; pi->compno++) {
+				comp = &pi->comps[pi->compno];
+				if (pi->resno >= comp->numresolutions) {
+					continue;
+				}
+				res = &comp->resolutions[pi->resno];
+				if (!pi->tp_on){
+					pi->poc.precno1 = res->pw * res->ph;
+				}
+				for (pi->precno = pi->poc.precno0; pi->precno < pi->poc.precno1; pi->precno++) {
+					index = pi->layno * pi->step_l + pi->resno * pi->step_r + pi->compno * pi->step_c + pi->precno * pi->step_p;
+					if (!pi->include[index]) {
+						pi->include[index] = 1;
+						return OPJ_TRUE;
+					}
+LABEL_SKIP:;
+				}
+			}
+		}
+	}
+	
+	return OPJ_FALSE;
+}
+
+static opj_bool pi_next_rlcp(opj_pi_iterator_t * pi) {
+	opj_pi_comp_t *comp = NULL;
+	opj_pi_resolution_t *res = NULL;
+	long index = 0;
+
+	if (!pi->first) {
+		comp = &pi->comps[pi->compno];
+		res = &comp->resolutions[pi->resno];
+		goto LABEL_SKIP;
+	} else {
+		pi->first = 0;
+	}
+
+	for (pi->resno = pi->poc.resno0; pi->resno < pi->poc.resno1; pi->resno++) {
+		for (pi->layno = pi->poc.layno0; pi->layno < pi->poc.layno1; pi->layno++) {
+			for (pi->compno = pi->poc.compno0; pi->compno < pi->poc.compno1; pi->compno++) {
+				comp = &pi->comps[pi->compno];
+				if (pi->resno >= comp->numresolutions) {
+					continue;
+				}
+				res = &comp->resolutions[pi->resno];
+				if(!pi->tp_on){
+					pi->poc.precno1 = res->pw * res->ph;
+				}
+				for (pi->precno = pi->poc.precno0; pi->precno < pi->poc.precno1; pi->precno++) {
+					index = pi->layno * pi->step_l + pi->resno * pi->step_r + pi->compno * pi->step_c + pi->precno * pi->step_p;
+					if (!pi->include[index]) {
+						pi->include[index] = 1;
+						return OPJ_TRUE;
+					}
+LABEL_SKIP:;
+				}
+			}
+		}
+	}
+	
+	return OPJ_FALSE;
+}
+
+static opj_bool pi_next_rpcl(opj_pi_iterator_t * pi) {
+	opj_pi_comp_t *comp = NULL;
+	opj_pi_resolution_t *res = NULL;
+	long index = 0;
+
+	if (!pi->first) {
+		goto LABEL_SKIP;
+	} else {
+		int compno, resno;
+		pi->first = 0;
+		pi->dx = 0;
+		pi->dy = 0;
+		for (compno = 0; compno < pi->numcomps; compno++) {
+			comp = &pi->comps[compno];
+			for (resno = 0; resno < comp->numresolutions; resno++) {
+				int dx, dy;
+				res = &comp->resolutions[resno];
+				dx = comp->dx * (1 << (res->pdx + comp->numresolutions - 1 - resno));
+				dy = comp->dy * (1 << (res->pdy + comp->numresolutions - 1 - resno));
+				pi->dx = !pi->dx ? dx : int_min(pi->dx, dx);
+				pi->dy = !pi->dy ? dy : int_min(pi->dy, dy);
+			}
+		}
+	}
+if (!pi->tp_on){
+			pi->poc.ty0 = pi->ty0;
+			pi->poc.tx0 = pi->tx0;
+			pi->poc.ty1 = pi->ty1;
+			pi->poc.tx1 = pi->tx1;
+		}
+	for (pi->resno = pi->poc.resno0; pi->resno < pi->poc.resno1; pi->resno++) {
+		for (pi->y = pi->poc.ty0; pi->y < pi->poc.ty1; pi->y += pi->dy - (pi->y % pi->dy)) {
+			for (pi->x = pi->poc.tx0; pi->x < pi->poc.tx1; pi->x += pi->dx - (pi->x % pi->dx)) {
+				for (pi->compno = pi->poc.compno0; pi->compno < pi->poc.compno1; pi->compno++) {
+					int levelno;
+					int trx0, try0;
+					int trx1, try1;
+					int rpx, rpy;
+					int prci, prcj;
+					comp = &pi->comps[pi->compno];
+					if (pi->resno >= comp->numresolutions) {
+						continue;
+					}
+					res = &comp->resolutions[pi->resno];
+					levelno = comp->numresolutions - 1 - pi->resno;
+					trx0 = int_ceildiv(pi->tx0, comp->dx << levelno);
+					try0 = int_ceildiv(pi->ty0, comp->dy << levelno);
+					trx1 = int_ceildiv(pi->tx1, comp->dx << levelno);
+					try1 = int_ceildiv(pi->ty1, comp->dy << levelno);
+					rpx = res->pdx + levelno;
+					rpy = res->pdy + levelno;
+					if (!((pi->y % (comp->dy << rpy) == 0) || ((pi->y == pi->ty0) && ((try0 << levelno) % (1 << rpy))))){
+						continue;	
+					}
+					if (!((pi->x % (comp->dx << rpx) == 0) || ((pi->x == pi->tx0) && ((trx0 << levelno) % (1 << rpx))))){
+						continue; 
+					}
+					
+					if ((res->pw==0)||(res->ph==0)) continue;
+					
+					if ((trx0==trx1)||(try0==try1)) continue;
+					
+					prci = int_floordivpow2(int_ceildiv(pi->x, comp->dx << levelno), res->pdx) 
+						 - int_floordivpow2(trx0, res->pdx);
+					prcj = int_floordivpow2(int_ceildiv(pi->y, comp->dy << levelno), res->pdy) 
+						 - int_floordivpow2(try0, res->pdy);
+					pi->precno = prci + prcj * res->pw;
+					for (pi->layno = pi->poc.layno0; pi->layno < pi->poc.layno1; pi->layno++) {
+						index = pi->layno * pi->step_l + pi->resno * pi->step_r + pi->compno * pi->step_c + pi->precno * pi->step_p;
+						if (!pi->include[index]) {
+							pi->include[index] = 1;
+							return OPJ_TRUE;
+						}
+LABEL_SKIP:;
+					}
+				}
+			}
+		}
+	}
+	
+	return OPJ_FALSE;
+}
+
+static opj_bool pi_next_pcrl(opj_pi_iterator_t * pi) {
+	opj_pi_comp_t *comp = NULL;
+	opj_pi_resolution_t *res = NULL;
+	long index = 0;
+
+	if (!pi->first) {
+		comp = &pi->comps[pi->compno];
+		goto LABEL_SKIP;
+	} else {
+		int compno, resno;
+		pi->first = 0;
+		pi->dx = 0;
+		pi->dy = 0;
+		for (compno = 0; compno < pi->numcomps; compno++) {
+			comp = &pi->comps[compno];
+			for (resno = 0; resno < comp->numresolutions; resno++) {
+				int dx, dy;
+				res = &comp->resolutions[resno];
+				dx = comp->dx * (1 << (res->pdx + comp->numresolutions - 1 - resno));
+				dy = comp->dy * (1 << (res->pdy + comp->numresolutions - 1 - resno));
+				pi->dx = !pi->dx ? dx : int_min(pi->dx, dx);
+				pi->dy = !pi->dy ? dy : int_min(pi->dy, dy);
+			}
+		}
+	}
+	if (!pi->tp_on){
+			pi->poc.ty0 = pi->ty0;
+			pi->poc.tx0 = pi->tx0;
+			pi->poc.ty1 = pi->ty1;
+			pi->poc.tx1 = pi->tx1;
+		}
+	for (pi->y = pi->poc.ty0; pi->y < pi->poc.ty1; pi->y += pi->dy - (pi->y % pi->dy)) {
+		for (pi->x = pi->poc.tx0; pi->x < pi->poc.tx1; pi->x += pi->dx - (pi->x % pi->dx)) {
+			for (pi->compno = pi->poc.compno0; pi->compno < pi->poc.compno1; pi->compno++) {
+				comp = &pi->comps[pi->compno];
+				for (pi->resno = pi->poc.resno0; pi->resno < int_min(pi->poc.resno1, comp->numresolutions); pi->resno++) {
+					int levelno;
+					int trx0, try0;
+					int trx1, try1;
+					int rpx, rpy;
+					int prci, prcj;
+					res = &comp->resolutions[pi->resno];
+					levelno = comp->numresolutions - 1 - pi->resno;
+					trx0 = int_ceildiv(pi->tx0, comp->dx << levelno);
+					try0 = int_ceildiv(pi->ty0, comp->dy << levelno);
+					trx1 = int_ceildiv(pi->tx1, comp->dx << levelno);
+					try1 = int_ceildiv(pi->ty1, comp->dy << levelno);
+					rpx = res->pdx + levelno;
+					rpy = res->pdy + levelno;
+					if (!((pi->y % (comp->dy << rpy) == 0) || ((pi->y == pi->ty0) && ((try0 << levelno) % (1 << rpy))))){
+						continue;	
+					}
+					if (!((pi->x % (comp->dx << rpx) == 0) || ((pi->x == pi->tx0) && ((trx0 << levelno) % (1 << rpx))))){
+						continue; 
+					}
+					
+					if ((res->pw==0)||(res->ph==0)) continue;
+					
+					if ((trx0==trx1)||(try0==try1)) continue;
+					
+					prci = int_floordivpow2(int_ceildiv(pi->x, comp->dx << levelno), res->pdx) 
+						 - int_floordivpow2(trx0, res->pdx);
+					prcj = int_floordivpow2(int_ceildiv(pi->y, comp->dy << levelno), res->pdy) 
+						 - int_floordivpow2(try0, res->pdy);
+					pi->precno = prci + prcj * res->pw;
+					for (pi->layno = pi->poc.layno0; pi->layno < pi->poc.layno1; pi->layno++) {
+						index = pi->layno * pi->step_l + pi->resno * pi->step_r + pi->compno * pi->step_c + pi->precno * pi->step_p;
+						if (!pi->include[index]) {
+							pi->include[index] = 1;
+							return OPJ_TRUE;
+						}	
+LABEL_SKIP:;
+					}
+				}
+			}
+		}
+	}
+	
+	return OPJ_FALSE;
+}
+
+static opj_bool pi_next_cprl(opj_pi_iterator_t * pi) {
+	opj_pi_comp_t *comp = NULL;
+	opj_pi_resolution_t *res = NULL;
+	long index = 0;
+
+	if (!pi->first) {
+		comp = &pi->comps[pi->compno];
+		goto LABEL_SKIP;
+	} else {
+		pi->first = 0;
+	}
+
+	for (pi->compno = pi->poc.compno0; pi->compno < pi->poc.compno1; pi->compno++) {
+		int resno;
+		comp = &pi->comps[pi->compno];
+		pi->dx = 0;
+		pi->dy = 0;
+		for (resno = 0; resno < comp->numresolutions; resno++) {
+			int dx, dy;
+			res = &comp->resolutions[resno];
+			dx = comp->dx * (1 << (res->pdx + comp->numresolutions - 1 - resno));
+			dy = comp->dy * (1 << (res->pdy + comp->numresolutions - 1 - resno));
+			pi->dx = !pi->dx ? dx : int_min(pi->dx, dx);
+			pi->dy = !pi->dy ? dy : int_min(pi->dy, dy);
+		}
+		if (!pi->tp_on){
+			pi->poc.ty0 = pi->ty0;
+			pi->poc.tx0 = pi->tx0;
+			pi->poc.ty1 = pi->ty1;
+			pi->poc.tx1 = pi->tx1;
+		}
+		for (pi->y = pi->poc.ty0; pi->y < pi->poc.ty1; pi->y += pi->dy - (pi->y % pi->dy)) {
+			for (pi->x = pi->poc.tx0; pi->x < pi->poc.tx1; pi->x += pi->dx - (pi->x % pi->dx)) {
+				for (pi->resno = pi->poc.resno0; pi->resno < int_min(pi->poc.resno1, comp->numresolutions); pi->resno++) {
+					int levelno;
+					int trx0, try0;
+					int trx1, try1;
+					int rpx, rpy;
+					int prci, prcj;
+					res = &comp->resolutions[pi->resno];
+					levelno = comp->numresolutions - 1 - pi->resno;
+					trx0 = int_ceildiv(pi->tx0, comp->dx << levelno);
+					try0 = int_ceildiv(pi->ty0, comp->dy << levelno);
+					trx1 = int_ceildiv(pi->tx1, comp->dx << levelno);
+					try1 = int_ceildiv(pi->ty1, comp->dy << levelno);
+					rpx = res->pdx + levelno;
+					rpy = res->pdy + levelno;
+					if (!((pi->y % (comp->dy << rpy) == 0) || ((pi->y == pi->ty0) && ((try0 << levelno) % (1 << rpy))))){
+						continue;	
+					}
+					if (!((pi->x % (comp->dx << rpx) == 0) || ((pi->x == pi->tx0) && ((trx0 << levelno) % (1 << rpx))))){
+						continue; 
+					}
+					
+					if ((res->pw==0)||(res->ph==0)) continue;
+					
+					if ((trx0==trx1)||(try0==try1)) continue;
+					
+					prci = int_floordivpow2(int_ceildiv(pi->x, comp->dx << levelno), res->pdx) 
+						 - int_floordivpow2(trx0, res->pdx);
+					prcj = int_floordivpow2(int_ceildiv(pi->y, comp->dy << levelno), res->pdy) 
+						 - int_floordivpow2(try0, res->pdy);
+					pi->precno = prci + prcj * res->pw;
+					for (pi->layno = pi->poc.layno0; pi->layno < pi->poc.layno1; pi->layno++) {
+						index = pi->layno * pi->step_l + pi->resno * pi->step_r + pi->compno * pi->step_c + pi->precno * pi->step_p;
+						if (!pi->include[index]) {
+							pi->include[index] = 1;
+							return OPJ_TRUE;
+						}
+LABEL_SKIP:;
+					}
+				}
+			}
+		}
+	}
+	
+	return OPJ_FALSE;
+}
+
+/* 
+==========================================================
+   Packet iterator interface
+==========================================================
+*/
+
+opj_pi_iterator_t *pi_create_decode(opj_image_t *image, opj_cp_t *cp, int tileno) {
+	int p, q;
+	int compno, resno, pino;
+	opj_pi_iterator_t *pi = NULL;
+	opj_tcp_t *tcp = NULL;
+	opj_tccp_t *tccp = NULL;
+
+	tcp = &cp->tcps[tileno];
+
+	pi = (opj_pi_iterator_t*) opj_calloc((tcp->numpocs + 1), sizeof(opj_pi_iterator_t));
+	if(!pi) {
+		/* TODO: throw an error */
+		return NULL;
+	}
+
+	for (pino = 0; pino < tcp->numpocs + 1; pino++) {	/* change */
+		int maxres = 0;
+		int maxprec = 0;
+		p = tileno % cp->tw;
+		q = tileno / cp->tw;
+
+		pi[pino].tx0 = int_max(cp->tx0 + p * cp->tdx, image->x0);
+		pi[pino].ty0 = int_max(cp->ty0 + q * cp->tdy, image->y0);
+		pi[pino].tx1 = int_min(cp->tx0 + (p + 1) * cp->tdx, image->x1);
+		pi[pino].ty1 = int_min(cp->ty0 + (q + 1) * cp->tdy, image->y1);
+		pi[pino].numcomps = image->numcomps;
+
+		pi[pino].comps = (opj_pi_comp_t*) opj_calloc(image->numcomps, sizeof(opj_pi_comp_t));
+		if(!pi[pino].comps) {
+			/* TODO: throw an error */
+			pi_destroy(pi, cp, tileno);
+			return NULL;
+		}
+		
+		for (compno = 0; compno < pi->numcomps; compno++) {
+			int tcx0, tcy0, tcx1, tcy1;
+			opj_pi_comp_t *comp = &pi[pino].comps[compno];
+			tccp = &tcp->tccps[compno];
+			comp->dx = image->comps[compno].dx;
+			comp->dy = image->comps[compno].dy;
+			comp->numresolutions = tccp->numresolutions;
+
+			comp->resolutions = (opj_pi_resolution_t*) opj_calloc(comp->numresolutions, sizeof(opj_pi_resolution_t));
+			if(!comp->resolutions) {
+				/* TODO: throw an error */
+				pi_destroy(pi, cp, tileno);
+				return NULL;
+			}
+
+			tcx0 = int_ceildiv(pi->tx0, comp->dx);
+			tcy0 = int_ceildiv(pi->ty0, comp->dy);
+			tcx1 = int_ceildiv(pi->tx1, comp->dx);
+			tcy1 = int_ceildiv(pi->ty1, comp->dy);
+			if (comp->numresolutions > maxres) {
+				maxres = comp->numresolutions;
+			}
+
+			for (resno = 0; resno < comp->numresolutions; resno++) {
+				int levelno;
+				int rx0, ry0, rx1, ry1;
+				int px0, py0, px1, py1;
+				opj_pi_resolution_t *res = &comp->resolutions[resno];
+				if (tccp->csty & J2K_CCP_CSTY_PRT) {
+					res->pdx = tccp->prcw[resno];
+					res->pdy = tccp->prch[resno];
+				} else {
+					res->pdx = 15;
+					res->pdy = 15;
+				}
+				levelno = comp->numresolutions - 1 - resno;
+				rx0 = int_ceildivpow2(tcx0, levelno);
+				ry0 = int_ceildivpow2(tcy0, levelno);
+				rx1 = int_ceildivpow2(tcx1, levelno);
+				ry1 = int_ceildivpow2(tcy1, levelno);
+				px0 = int_floordivpow2(rx0, res->pdx) << res->pdx;
+				py0 = int_floordivpow2(ry0, res->pdy) << res->pdy;
+				px1 = int_ceildivpow2(rx1, res->pdx) << res->pdx;
+				py1 = int_ceildivpow2(ry1, res->pdy) << res->pdy;
+				res->pw = (rx0==rx1)?0:((px1 - px0) >> res->pdx);
+				res->ph = (ry0==ry1)?0:((py1 - py0) >> res->pdy);
+				
+				if (res->pw*res->ph > maxprec) {
+					maxprec = res->pw*res->ph;
+				}
+				
+			}
+		}
+		
+		tccp = &tcp->tccps[0];
+		pi[pino].step_p = 1;
+		pi[pino].step_c = maxprec * pi[pino].step_p;
+		pi[pino].step_r = image->numcomps * pi[pino].step_c;
+		pi[pino].step_l = maxres * pi[pino].step_r;
+		
+		if (pino == 0) {
+			pi[pino].include = (short int*) opj_calloc(image->numcomps * maxres * tcp->numlayers * maxprec, sizeof(short int));
+			if(!pi[pino].include) {
+				/* TODO: throw an error */
+				pi_destroy(pi, cp, tileno);
+				return NULL;
+			}
+		}
+		else {
+			pi[pino].include = pi[pino - 1].include;
+		}
+		
+		if (tcp->POC == 0) {
+			pi[pino].first = 1;
+			pi[pino].poc.resno0 = 0;
+			pi[pino].poc.compno0 = 0;
+			pi[pino].poc.layno1 = tcp->numlayers;
+			pi[pino].poc.resno1 = maxres;
+			pi[pino].poc.compno1 = image->numcomps;
+			pi[pino].poc.prg = tcp->prg;
+		} else {
+			pi[pino].first = 1;
+			pi[pino].poc.resno0 = tcp->pocs[pino].resno0;
+			pi[pino].poc.compno0 = tcp->pocs[pino].compno0;
+			pi[pino].poc.layno1 = tcp->pocs[pino].layno1;
+			pi[pino].poc.resno1 = tcp->pocs[pino].resno1;
+			pi[pino].poc.compno1 = tcp->pocs[pino].compno1;
+			pi[pino].poc.prg = tcp->pocs[pino].prg;
+		}
+		pi[pino].poc.layno0  = 0;
+		pi[pino].poc.precno0 = 0; 
+		pi[pino].poc.precno1 = maxprec;
+			
+	}
+	
+	return pi;
+}
+
+
+opj_pi_iterator_t *pi_initialise_encode(opj_image_t *image, opj_cp_t *cp, int tileno, J2K_T2_MODE t2_mode){ 
+	int p, q, pino;
+	int compno, resno;
+	int maxres = 0;
+	int maxprec = 0;
+	opj_pi_iterator_t *pi = NULL;
+	opj_tcp_t *tcp = NULL;
+	opj_tccp_t *tccp = NULL;
+	
+	tcp = &cp->tcps[tileno];
+
+	pi = (opj_pi_iterator_t*) opj_calloc((tcp->numpocs + 1), sizeof(opj_pi_iterator_t));
+	if(!pi) {	return NULL;}
+	pi->tp_on = cp->tp_on;
+
+	for(pino = 0;pino < tcp->numpocs+1 ; pino ++){
+		p = tileno % cp->tw;
+		q = tileno / cp->tw;
+
+		pi[pino].tx0 = int_max(cp->tx0 + p * cp->tdx, image->x0);
+		pi[pino].ty0 = int_max(cp->ty0 + q * cp->tdy, image->y0);
+		pi[pino].tx1 = int_min(cp->tx0 + (p + 1) * cp->tdx, image->x1);
+		pi[pino].ty1 = int_min(cp->ty0 + (q + 1) * cp->tdy, image->y1);
+		pi[pino].numcomps = image->numcomps;
+		
+		pi[pino].comps = (opj_pi_comp_t*) opj_calloc(image->numcomps, sizeof(opj_pi_comp_t));
+		if(!pi[pino].comps) {
+			pi_destroy(pi, cp, tileno);
+			return NULL;
+		}
+		
+		for (compno = 0; compno < pi[pino].numcomps; compno++) {
+			int tcx0, tcy0, tcx1, tcy1;
+			opj_pi_comp_t *comp = &pi[pino].comps[compno];
+			tccp = &tcp->tccps[compno];
+			comp->dx = image->comps[compno].dx;
+			comp->dy = image->comps[compno].dy;
+			comp->numresolutions = tccp->numresolutions;
+
+			comp->resolutions = (opj_pi_resolution_t*) opj_malloc(comp->numresolutions * sizeof(opj_pi_resolution_t));
+			if(!comp->resolutions) {
+				pi_destroy(pi, cp, tileno);
+				return NULL;
+			}
+
+			tcx0 = int_ceildiv(pi[pino].tx0, comp->dx);
+			tcy0 = int_ceildiv(pi[pino].ty0, comp->dy);
+			tcx1 = int_ceildiv(pi[pino].tx1, comp->dx);
+			tcy1 = int_ceildiv(pi[pino].ty1, comp->dy);
+			if (comp->numresolutions > maxres) {
+				maxres = comp->numresolutions;
+			}
+
+			for (resno = 0; resno < comp->numresolutions; resno++) {
+				int levelno;
+				int rx0, ry0, rx1, ry1;
+				int px0, py0, px1, py1;
+				opj_pi_resolution_t *res = &comp->resolutions[resno];
+				if (tccp->csty & J2K_CCP_CSTY_PRT) {
+					res->pdx = tccp->prcw[resno];
+					res->pdy = tccp->prch[resno];
+				} else {
+					res->pdx = 15;
+					res->pdy = 15;
+				}
+				levelno = comp->numresolutions - 1 - resno;
+				rx0 = int_ceildivpow2(tcx0, levelno);
+				ry0 = int_ceildivpow2(tcy0, levelno);
+				rx1 = int_ceildivpow2(tcx1, levelno);
+				ry1 = int_ceildivpow2(tcy1, levelno);
+				px0 = int_floordivpow2(rx0, res->pdx) << res->pdx;
+				py0 = int_floordivpow2(ry0, res->pdy) << res->pdy;
+				px1 = int_ceildivpow2(rx1, res->pdx) << res->pdx;
+				py1 = int_ceildivpow2(ry1, res->pdy) << res->pdy;
+				res->pw = (rx0==rx1)?0:((px1 - px0) >> res->pdx);
+				res->ph = (ry0==ry1)?0:((py1 - py0) >> res->pdy);
+
+				if (res->pw*res->ph > maxprec) {
+					maxprec = res->pw * res->ph;
+				}
+			}
+		}
+		
+		tccp = &tcp->tccps[0];
+		pi[pino].step_p = 1;
+		pi[pino].step_c = maxprec * pi[pino].step_p;
+		pi[pino].step_r = image->numcomps * pi[pino].step_c;
+		pi[pino].step_l = maxres * pi[pino].step_r;
+		
+		for (compno = 0; compno < pi->numcomps; compno++) {
+			opj_pi_comp_t *comp = &pi->comps[compno];
+			for (resno = 0; resno < comp->numresolutions; resno++) {
+				int dx, dy;
+				opj_pi_resolution_t *res = &comp->resolutions[resno];
+				dx = comp->dx * (1 << (res->pdx + comp->numresolutions - 1 - resno));
+				dy = comp->dy * (1 << (res->pdy + comp->numresolutions - 1 - resno));
+				pi[pino].dx = !pi->dx ? dx : int_min(pi->dx, dx);
+				pi[pino].dy = !pi->dy ? dy : int_min(pi->dy, dy);
+			}
+		}
+
+		if (pino == 0) {
+			pi[pino].include = (short int*) opj_calloc(tcp->numlayers * pi[pino].step_l, sizeof(short int));
+			if(!pi[pino].include) {
+				pi_destroy(pi, cp, tileno);
+				return NULL;
+			}
+		}
+		else {
+			pi[pino].include = pi[pino - 1].include;
+		}
+		
+		/* Generation of boundaries for each prog flag*/
+			if(tcp->POC && ( cp->cinema || ((!cp->cinema) && (t2_mode == FINAL_PASS)))){
+				tcp->pocs[pino].compS= tcp->pocs[pino].compno0;
+				tcp->pocs[pino].compE= tcp->pocs[pino].compno1;
+				tcp->pocs[pino].resS = tcp->pocs[pino].resno0;
+				tcp->pocs[pino].resE = tcp->pocs[pino].resno1;
+				tcp->pocs[pino].layE = tcp->pocs[pino].layno1;
+				tcp->pocs[pino].prg  = tcp->pocs[pino].prg1;
+				if (pino > 0)
+					tcp->pocs[pino].layS = (tcp->pocs[pino].layE > tcp->pocs[pino - 1].layE) ? tcp->pocs[pino - 1].layE : 0;
+			}else {
+				tcp->pocs[pino].compS= 0;
+				tcp->pocs[pino].compE= image->numcomps;
+				tcp->pocs[pino].resS = 0;
+				tcp->pocs[pino].resE = maxres;
+				tcp->pocs[pino].layS = 0;
+				tcp->pocs[pino].layE = tcp->numlayers;
+				tcp->pocs[pino].prg  = tcp->prg;
+			}
+			tcp->pocs[pino].prcS = 0;
+			tcp->pocs[pino].prcE = maxprec;;
+			tcp->pocs[pino].txS = pi[pino].tx0;
+			tcp->pocs[pino].txE = pi[pino].tx1;
+			tcp->pocs[pino].tyS = pi[pino].ty0;
+			tcp->pocs[pino].tyE = pi[pino].ty1;
+			tcp->pocs[pino].dx = pi[pino].dx;
+			tcp->pocs[pino].dy = pi[pino].dy;
+		}
+			return pi;
+	}
+
+
+
+void pi_destroy(opj_pi_iterator_t *pi, opj_cp_t *cp, int tileno) {
+	int compno, pino;
+	opj_tcp_t *tcp = &cp->tcps[tileno];
+	if(pi) {
+		for (pino = 0; pino < tcp->numpocs + 1; pino++) {	
+			if(pi[pino].comps) {
+				for (compno = 0; compno < pi->numcomps; compno++) {
+					opj_pi_comp_t *comp = &pi[pino].comps[compno];
+					if(comp->resolutions) {
+						opj_free(comp->resolutions);
+					}
+				}
+				opj_free(pi[pino].comps);
+			}
+		}
+		if(pi->include) {
+			opj_free(pi->include);
+		}
+		opj_free(pi);
+	}
+}
+
+opj_bool pi_next(opj_pi_iterator_t * pi) {
+	switch (pi->poc.prg) {
+		case LRCP:
+			return pi_next_lrcp(pi);
+		case RLCP:
+			return pi_next_rlcp(pi);
+		case RPCL:
+			return pi_next_rpcl(pi);
+		case PCRL:
+			return pi_next_pcrl(pi);
+		case CPRL:
+			return pi_next_cprl(pi);
+		case PROG_UNKNOWN:
+			return OPJ_FALSE;
+	}
+	
+	return OPJ_FALSE;
+}
+
+opj_bool pi_create_encode( opj_pi_iterator_t *pi, opj_cp_t *cp,int tileno, int pino,int tpnum, int tppos, J2K_T2_MODE t2_mode,int cur_totnum_tp){
+	char prog[4];
+	int i;
+	int incr_top=1,resetX=0;
+	opj_tcp_t *tcps =&cp->tcps[tileno];
+	opj_poc_t *tcp= &tcps->pocs[pino];
+
+	pi[pino].first = 1;
+	pi[pino].poc.prg = tcp->prg;
+
+	switch(tcp->prg){
+		case CPRL: strncpy(prog, "CPRL",4);
+			break;
+		case LRCP: strncpy(prog, "LRCP",4);
+			break;
+		case PCRL: strncpy(prog, "PCRL",4);
+			break;
+		case RLCP: strncpy(prog, "RLCP",4);
+			break;
+		case RPCL: strncpy(prog, "RPCL",4);
+			break;
+		case PROG_UNKNOWN: 
+			return OPJ_TRUE;
+	}
+
+	if(!(cp->tp_on && ((!cp->cinema && (t2_mode == FINAL_PASS)) || cp->cinema))){
+		pi[pino].poc.resno0 = tcp->resS;
+		pi[pino].poc.resno1 = tcp->resE;
+		pi[pino].poc.compno0 = tcp->compS;
+		pi[pino].poc.compno1 = tcp->compE;
+		pi[pino].poc.layno0 = tcp->layS;
+		pi[pino].poc.layno1 = tcp->layE;
+		pi[pino].poc.precno0 = tcp->prcS;
+		pi[pino].poc.precno1 = tcp->prcE;
+		pi[pino].poc.tx0 = tcp->txS;
+		pi[pino].poc.ty0 = tcp->tyS;
+		pi[pino].poc.tx1 = tcp->txE;
+		pi[pino].poc.ty1 = tcp->tyE;
+	}else {
+		if( tpnum < cur_totnum_tp){
+			for(i=3;i>=0;i--){
+				switch(prog[i]){
+				case 'C':
+					if (i > tppos){
+						pi[pino].poc.compno0 = tcp->compS;
+						pi[pino].poc.compno1 = tcp->compE;
+					}else{
+						if (tpnum == 0){
+							tcp->comp_t = tcp->compS;
+							pi[pino].poc.compno0 = tcp->comp_t;
+							pi[pino].poc.compno1 = tcp->comp_t+1;
+							tcp->comp_t+=1;
+						}else{
+							if (incr_top == 1){
+								if(tcp->comp_t ==tcp->compE){
+									tcp->comp_t = tcp->compS;
+									pi[pino].poc.compno0 = tcp->comp_t;
+									pi[pino].poc.compno1 = tcp->comp_t+1;
+									tcp->comp_t+=1;
+									incr_top=1;
+								}else{
+									pi[pino].poc.compno0 = tcp->comp_t;
+									pi[pino].poc.compno1 = tcp->comp_t+1;
+									tcp->comp_t+=1;
+									incr_top=0;
+								}
+							}else{
+								pi[pino].poc.compno0 = tcp->comp_t-1;
+								pi[pino].poc.compno1 = tcp->comp_t;
+							}
+						}
+					}
+					break;
+
+				case 'R':
+					if (i > tppos){
+						pi[pino].poc.resno0 = tcp->resS;
+						pi[pino].poc.resno1 = tcp->resE;
+					}else{
+						if (tpnum == 0){
+							tcp->res_t = tcp->resS;
+							pi[pino].poc.resno0 = tcp->res_t;
+							pi[pino].poc.resno1 = tcp->res_t+1;
+							tcp->res_t+=1;
+						}else{
+							if (incr_top == 1){
+								if(tcp->res_t==tcp->resE){
+									tcp->res_t = tcp->resS;
+									pi[pino].poc.resno0 = tcp->res_t;
+									pi[pino].poc.resno1 = tcp->res_t+1;
+									tcp->res_t+=1;
+									incr_top=1;
+								}else{
+									pi[pino].poc.resno0 = tcp->res_t;
+									pi[pino].poc.resno1 = tcp->res_t+1;
+									tcp->res_t+=1;
+									incr_top=0;
+								}
+							}else{
+								pi[pino].poc.resno0 = tcp->res_t - 1;
+								pi[pino].poc.resno1 = tcp->res_t;
+							}
+						}
+					}
+					break;
+
+				case 'L':
+					if (i > tppos){
+						pi[pino].poc.layno0 = tcp->layS;
+						pi[pino].poc.layno1 = tcp->layE;
+					}else{
+						if (tpnum == 0){
+							tcp->lay_t = tcp->layS;
+							pi[pino].poc.layno0 = tcp->lay_t;
+							pi[pino].poc.layno1 = tcp->lay_t+1;
+							tcp->lay_t+=1;
+						}else{
+							if (incr_top == 1){
+								if(tcp->lay_t == tcp->layE){
+									tcp->lay_t = tcp->layS;
+									pi[pino].poc.layno0 = tcp->lay_t;
+									pi[pino].poc.layno1 = tcp->lay_t+1;
+									tcp->lay_t+=1;
+									incr_top=1;
+								}else{
+									pi[pino].poc.layno0 = tcp->lay_t;
+									pi[pino].poc.layno1 = tcp->lay_t+1;
+									tcp->lay_t+=1;
+									incr_top=0;
+								}
+							}else{
+								pi[pino].poc.layno0 = tcp->lay_t - 1;
+								pi[pino].poc.layno1 = tcp->lay_t;
+							}
+						}
+					}
+					break;
+
+				case 'P':
+					switch(tcp->prg){
+						case LRCP:
+						case RLCP:
+							if (i > tppos){
+								pi[pino].poc.precno0 = tcp->prcS;
+								pi[pino].poc.precno1 = tcp->prcE;
+							}else{
+								if (tpnum == 0){
+									tcp->prc_t = tcp->prcS;
+									pi[pino].poc.precno0 = tcp->prc_t;
+									pi[pino].poc.precno1 = tcp->prc_t+1;
+									tcp->prc_t+=1; 
+								}else{
+									if (incr_top == 1){
+										if(tcp->prc_t == tcp->prcE){
+											tcp->prc_t = tcp->prcS;
+											pi[pino].poc.precno0 = tcp->prc_t;
+											pi[pino].poc.precno1 = tcp->prc_t+1;
+											tcp->prc_t+=1;
+											incr_top=1;
+										}else{
+											pi[pino].poc.precno0 = tcp->prc_t;
+											pi[pino].poc.precno1 = tcp->prc_t+1;
+											tcp->prc_t+=1;
+											incr_top=0;
+										}
+									}else{
+										pi[pino].poc.precno0 = tcp->prc_t - 1;
+										pi[pino].poc.precno1 = tcp->prc_t;
+									}
+								}
+							}
+						break;
+						default:
+							if (i > tppos){
+								pi[pino].poc.tx0 = tcp->txS;
+								pi[pino].poc.ty0 = tcp->tyS;
+								pi[pino].poc.tx1 = tcp->txE;
+								pi[pino].poc.ty1 = tcp->tyE;
+							}else{
+								if (tpnum == 0){
+									tcp->tx0_t = tcp->txS;
+									tcp->ty0_t = tcp->tyS;
+									pi[pino].poc.tx0 = tcp->tx0_t;
+									pi[pino].poc.tx1 = tcp->tx0_t + tcp->dx - (tcp->tx0_t % tcp->dx);
+									pi[pino].poc.ty0 = tcp->ty0_t;
+									pi[pino].poc.ty1 = tcp->ty0_t + tcp->dy - (tcp->ty0_t % tcp->dy);
+									tcp->tx0_t = pi[pino].poc.tx1;
+									tcp->ty0_t = pi[pino].poc.ty1;
+								}else{
+									if (incr_top == 1){
+										if(tcp->tx0_t >= tcp->txE){
+											if(tcp->ty0_t >= tcp->tyE){
+												tcp->ty0_t = tcp->tyS;
+												pi[pino].poc.ty0 = tcp->ty0_t;
+												pi[pino].poc.ty1 = tcp->ty0_t + tcp->dy - (tcp->ty0_t % tcp->dy);
+												tcp->ty0_t = pi[pino].poc.ty1;
+												incr_top=1;resetX=1;
+											}else{
+												pi[pino].poc.ty0 = tcp->ty0_t;
+												pi[pino].poc.ty1 = tcp->ty0_t + tcp->dy - (tcp->ty0_t % tcp->dy);
+												tcp->ty0_t = pi[pino].poc.ty1;
+												incr_top=0;resetX=1;
+											}
+											if(resetX==1){
+												tcp->tx0_t = tcp->txS;
+												pi[pino].poc.tx0 = tcp->tx0_t;
+												pi[pino].poc.tx1 = tcp->tx0_t + tcp->dx- (tcp->tx0_t % tcp->dx);
+												tcp->tx0_t = pi[pino].poc.tx1;
+											}
+										}else{
+											pi[pino].poc.tx0 = tcp->tx0_t;
+											pi[pino].poc.tx1 = tcp->tx0_t + tcp->dx- (tcp->tx0_t % tcp->dx);
+											tcp->tx0_t = pi[pino].poc.tx1;
+											pi[pino].poc.ty0 = tcp->ty0_t - tcp->dy - (tcp->ty0_t % tcp->dy);
+											pi[pino].poc.ty1 = tcp->ty0_t ;
+											incr_top=0;
+										}
+									}else{
+										pi[pino].poc.tx0 = tcp->tx0_t - tcp->dx - (tcp->tx0_t % tcp->dx);
+										pi[pino].poc.tx1 = tcp->tx0_t ;
+										pi[pino].poc.ty0 = tcp->ty0_t - tcp->dy - (tcp->ty0_t % tcp->dy);
+										pi[pino].poc.ty1 = tcp->ty0_t ;
+									}
+								}
+							}
+						break;
+						}
+						break;
+				}		
+			} 
+		}
+	}	
+	return OPJ_FALSE;
+}
+

src/add-ons/translators/icns/openjpeg/pi.h

@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __PI_H
+#define __PI_H
+/**
+@file pi.h
+@brief Implementation of a packet iterator (PI)
+
+The functions in PI.C have for goal to realize a packet iterator that permits to get the next
+packet following the progression order and change of it. The functions in PI.C are used
+by some function in T2.C.
+*/
+
+/** @defgroup PI PI - Implementation of a packet iterator */
+/*@{*/
+
+/**
+FIXME: documentation
+*/
+typedef struct opj_pi_resolution {
+  int pdx, pdy;
+  int pw, ph;
+} opj_pi_resolution_t;
+
+/**
+FIXME: documentation
+*/
+typedef struct opj_pi_comp {
+  int dx, dy;
+  /** number of resolution levels */
+  int numresolutions;
+  opj_pi_resolution_t *resolutions;
+} opj_pi_comp_t;
+
+/** 
+Packet iterator 
+*/
+typedef struct opj_pi_iterator {
+	/** Enabling Tile part generation*/
+	char tp_on;
+	/** precise if the packet has been already used (usefull for progression order change) */
+	short int *include;
+	/** layer step used to localize the packet in the include vector */
+	int step_l;
+	/** resolution step used to localize the packet in the include vector */
+	int step_r;	
+	/** component step used to localize the packet in the include vector */
+	int step_c;	
+	/** precinct step used to localize the packet in the include vector */
+	int step_p;	
+	/** component that identify the packet */
+	int compno;
+	/** resolution that identify the packet */
+	int resno;
+	/** precinct that identify the packet */
+	int precno;
+	/** layer that identify the packet */
+	int layno;   
+	/** 0 if the first packet */
+	int first;
+	/** progression order change information */
+	opj_poc_t poc;
+	/** number of components in the image */
+	int numcomps;
+	/** Components*/
+	opj_pi_comp_t *comps;
+	int tx0, ty0, tx1, ty1;
+	int x, y, dx, dy;
+} opj_pi_iterator_t;
+
+/** @name Exported functions */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+/**
+Create a packet iterator for Encoder
+@param image Raw image for which the packets will be listed
+@param cp Coding parameters
+@param tileno Number that identifies the tile for which to list the packets
+@param t2_mode If == 0 In Threshold calculation ,If == 1 Final pass
+@return Returns a packet iterator that points to the first packet of the tile
+@see pi_destroy
+*/
+opj_pi_iterator_t *pi_initialise_encode(opj_image_t *image, opj_cp_t *cp, int tileno,J2K_T2_MODE t2_mode);
+/**
+Modify the packet iterator for enabling tile part generation
+@param pi Handle to the packet iterator generated in pi_initialise_encode  
+@param cp Coding parameters
+@param tileno Number that identifies the tile for which to list the packets
+@param pino Iterator index for pi
+@param tpnum Tile part number of the current tile
+@param tppos The position of the tile part flag in the progression order
+@param t2_mode If == 0 In Threshold calculation ,If == 1 Final pass
+@param cur_totnum_tp The total number of tile parts in the current tile
+@return Returns true if an error is detected 
+*/
+opj_bool pi_create_encode(opj_pi_iterator_t *pi, opj_cp_t *cp,int tileno, int pino,int tpnum, int tppos, J2K_T2_MODE t2_mode,int cur_totnum_tp);
+/**
+Create a packet iterator for Decoder
+@param image Raw image for which the packets will be listed
+@param cp Coding parameters
+@param tileno Number that identifies the tile for which to list the packets
+@return Returns a packet iterator that points to the first packet of the tile
+@see pi_destroy
+*/
+opj_pi_iterator_t *pi_create_decode(opj_image_t * image, opj_cp_t * cp, int tileno);
+
+/**
+Destroy a packet iterator
+@param pi Previously created packet iterator
+@param cp Coding parameters
+@param tileno Number that identifies the tile for which the packets were listed
+@see pi_create
+*/
+void pi_destroy(opj_pi_iterator_t *pi, opj_cp_t *cp, int tileno);
+
+/**
+Modify the packet iterator to point to the next packet
+@param pi Packet iterator to modify
+@return Returns false if pi pointed to the last packet or else returns true 
+*/
+opj_bool pi_next(opj_pi_iterator_t * pi);
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __PI_H */

src/add-ons/translators/icns/openjpeg/ppix_manager.c

@@ -0,0 +1,173 @@
+/*
+ * $Id: ppix_manager.c 897 2011-08-28 21:43:57Z Kaori.Hagihara@gmail.com $
+ *
+ * Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2011, Professor Benoit Macq
+ * Copyright (c) 2003-2004, Yannick Verschueren
+ * Copyright (c) 2010-2011, Kaori Hagihara
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*! \file
+ *  \brief Modification of jpip.c from 2KAN indexer
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include "opj_includes.h"
+
+/* 
+ * Write faix box of ppix
+ *
+ * @param[in] coff offset of j2k codestream
+ * @param[in] compno    component number
+ * @param[in] cstr_info codestream information
+ * @param[in] EPHused   true if if EPH option used
+ * @param[in] j2klen    length of j2k codestream
+ * @param[in] cio       file output handle
+ * @return              length of faix box
+ */
+int write_ppixfaix( int coff, int compno, opj_codestream_info_t cstr_info, opj_bool EPHused, int j2klen, opj_cio_t *cio);
+
+int write_ppix( int coff, opj_codestream_info_t cstr_info, opj_bool EPHused, int j2klen, opj_cio_t *cio)
+{
+  int len, lenp, compno, i;
+  opj_jp2_box_t *box;
+
+  /*  printf("cstr_info.packno %d\n", cstr_info.packno); //NMAX? */
+
+  lenp = -1;
+  box = (opj_jp2_box_t *)opj_calloc( cstr_info.numcomps, sizeof(opj_jp2_box_t));
+  
+  for (i=0;i<2;i++){
+    if (i) cio_seek( cio, lenp);
+    
+    lenp = cio_tell( cio);
+    cio_skip( cio, 4);              /* L [at the end] */
+    cio_write( cio, JPIP_PPIX, 4);  /* PPIX           */
+
+    write_manf( i, cstr_info.numcomps, box, cio);
+    
+    for (compno=0; compno<cstr_info.numcomps; compno++){
+      box[compno].length = write_ppixfaix( coff, compno, cstr_info, EPHused, j2klen, cio);
+      box[compno].type = JPIP_FAIX;
+    }
+   
+    len = cio_tell( cio)-lenp;
+    cio_seek( cio, lenp);
+    cio_write( cio, len, 4);        /* L              */
+    cio_seek( cio, lenp+len);
+  }
+  
+  opj_free(box);
+
+  return len;
+}
+
+int write_ppixfaix( int coff, int compno, opj_codestream_info_t cstr_info, opj_bool EPHused, int j2klen, opj_cio_t *cio)
+{
+  int len, lenp, tileno, version, i, nmax, size_of_coding; /* 4 or 8*/
+  opj_tile_info_t *tile_Idx;
+  opj_packet_info_t packet;
+  int resno, precno, layno, num_packet;
+  int numOfres, numOfprec, numOflayers;
+  packet.end_pos = packet.end_ph_pos = packet.start_pos = -1;
+  (void)EPHused; /* unused ? */
+
+  if( j2klen > pow( 2, 32)){
+    size_of_coding =  8;
+    version = 1;
+  }
+  else{
+    size_of_coding = 4;
+    version = 0;
+  }
+  
+  lenp = cio_tell( cio);
+  cio_skip( cio, 4);              /* L [at the end]      */
+  cio_write( cio, JPIP_FAIX, 4);  /* FAIX                */ 
+  cio_write( cio, version, 1);     /* Version 0 = 4 bytes */
+
+  nmax = 0;
+  for( i=0; i<=cstr_info.numdecompos[compno]; i++)
+    nmax += cstr_info.tile[0].ph[i] * cstr_info.tile[0].pw[i] * cstr_info.numlayers;
+  
+  cio_write( cio, nmax, size_of_coding); /* NMAX */
+  cio_write( cio, cstr_info.tw*cstr_info.th, size_of_coding);      /* M    */
+
+  for( tileno=0; tileno<cstr_info.tw*cstr_info.th; tileno++){
+    tile_Idx = &cstr_info.tile[ tileno];
+ 
+    num_packet=0;
+    numOfres = cstr_info.numdecompos[compno] + 1;
+  
+    for( resno=0; resno<numOfres ; resno++){
+      numOfprec = tile_Idx->pw[resno]*tile_Idx->ph[resno];
+      for( precno=0; precno<numOfprec; precno++){
+	numOflayers = cstr_info.numlayers;
+	for( layno=0; layno<numOflayers; layno++){
+
+	  switch ( cstr_info.prog){
+	  case LRCP:
+	    packet = tile_Idx->packet[ ((layno*numOfres+resno)*cstr_info.numcomps+compno)*numOfprec+precno];
+	    break;
+	  case RLCP:
+	    packet = tile_Idx->packet[ ((resno*numOflayers+layno)*cstr_info.numcomps+compno)*numOfprec+precno];
+	    break;
+	  case RPCL:
+	    packet = tile_Idx->packet[ ((resno*numOfprec+precno)*cstr_info.numcomps+compno)*numOflayers+layno];
+	    break;
+	  case PCRL:
+	    packet = tile_Idx->packet[ ((precno*cstr_info.numcomps+compno)*numOfres+resno)*numOflayers + layno];
+	    break;
+	  case CPRL:
+	    packet = tile_Idx->packet[ ((compno*numOfprec+precno)*numOfres+resno)*numOflayers + layno];
+	    break;
+	  default:
+	    fprintf( stderr, "failed to ppix indexing\n");
+	  }
+
+	  cio_write( cio, packet.start_pos-coff, size_of_coding);             /* start position */
+	  cio_write( cio, packet.end_pos-packet.start_pos+1, size_of_coding); /* length         */
+	  
+	  num_packet++;
+	}
+      }
+    }
+  
+    while( num_packet < nmax){     /* PADDING */
+      cio_write( cio, 0, size_of_coding); /* start position            */
+      cio_write( cio, 0, size_of_coding); /* length                    */
+      num_packet++;
+    }   
+  }
+
+  len = cio_tell( cio)-lenp;
+  cio_seek( cio, lenp);
+  cio_write( cio, len, 4);        /* L  */
+  cio_seek( cio, lenp+len);
+
+  return len;
+}

src/add-ons/translators/icns/openjpeg/raw.c

@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "opj_includes.h"
+
+/* 
+==========================================================
+   local functions
+==========================================================
+*/
+
+
+/* 
+==========================================================
+   RAW encoding interface
+==========================================================
+*/
+
+opj_raw_t* raw_create(void) {
+	opj_raw_t *raw = (opj_raw_t*)opj_malloc(sizeof(opj_raw_t));
+	return raw;
+}
+
+void raw_destroy(opj_raw_t *raw) {
+	if(raw) {
+		opj_free(raw);
+	}
+}
+
+int raw_numbytes(opj_raw_t *raw) {
+	return raw->bp - raw->start;
+}
+
+void raw_init_dec(opj_raw_t *raw, unsigned char *bp, int len) {
+	raw->start = bp;
+	raw->lenmax = len;
+	raw->len = 0;
+	raw->c = 0;
+	raw->ct = 0;
+}
+
+int raw_decode(opj_raw_t *raw) {
+	int d;
+	if (raw->ct == 0) {
+		raw->ct = 8;
+		if (raw->len == raw->lenmax) {
+			raw->c = 0xff;
+		} else {
+			if (raw->c == 0xff) {
+				raw->ct = 7;
+			}
+			raw->c = *(raw->start + raw->len);
+			raw->len++;
+		}
+	}
+	raw->ct--;
+	d = (raw->c >> raw->ct) & 0x01;
+	
+	return d;
+}
+

src/add-ons/translators/icns/openjpeg/raw.h

@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __RAW_H
+#define __RAW_H
+/**
+@file raw.h
+@brief Implementation of operations for raw encoding (RAW)
+
+The functions in RAW.C have for goal to realize the operation of raw encoding linked
+with the corresponding mode switch.
+*/
+
+/** @defgroup RAW RAW - Implementation of operations for raw encoding */
+/*@{*/
+
+/**
+RAW encoding operations
+*/
+typedef struct opj_raw {
+	/** temporary buffer where bits are coded or decoded */
+	unsigned char c;
+	/** number of bits already read or free to write */
+	unsigned int ct;
+	/** maximum length to decode */
+	unsigned int lenmax;
+	/** length decoded */
+	unsigned int len;
+	/** pointer to the current position in the buffer */
+	unsigned char *bp;
+	/** pointer to the start of the buffer */
+	unsigned char *start;
+	/** pointer to the end of the buffer */
+	unsigned char *end;
+} opj_raw_t;
+
+/** @name Exported functions */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+/**
+Create a new RAW handle 
+@return Returns a new RAW handle if successful, returns NULL otherwise
+*/
+opj_raw_t* raw_create(void);
+/**
+Destroy a previously created RAW handle
+@param raw RAW handle to destroy
+*/
+void raw_destroy(opj_raw_t *raw);
+/**
+Return the number of bytes written/read since initialisation
+@param raw RAW handle to destroy
+@return Returns the number of bytes already encoded
+*/
+int raw_numbytes(opj_raw_t *raw);
+/**
+Initialize the decoder
+@param raw RAW handle
+@param bp Pointer to the start of the buffer from which the bytes will be read
+@param len Length of the input buffer
+*/
+void raw_init_dec(opj_raw_t *raw, unsigned char *bp, int len);
+/**
+Decode a symbol using raw-decoder. Cfr p.506 TAUBMAN
+@param raw RAW handle
+@return Returns the decoded symbol (0 or 1)
+*/
+int raw_decode(opj_raw_t *raw);
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __RAW_H */

src/add-ons/translators/icns/openjpeg/t1.h

@@ -0,0 +1,147 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __T1_H
+#define __T1_H
+/**
+@file t1.h
+@brief Implementation of the tier-1 coding (coding of code-block coefficients) (T1)
+
+The functions in T1.C have for goal to realize the tier-1 coding operation. The functions
+in T1.C are used by some function in TCD.C.
+*/
+
+/** @defgroup T1 T1 - Implementation of the tier-1 coding */
+/*@{*/
+
+/* ----------------------------------------------------------------------- */
+#define T1_NMSEDEC_BITS 7
+
+#define T1_SIG_NE 0x0001	/**< Context orientation : North-East direction */
+#define T1_SIG_SE 0x0002	/**< Context orientation : South-East direction */
+#define T1_SIG_SW 0x0004	/**< Context orientation : South-West direction */
+#define T1_SIG_NW 0x0008	/**< Context orientation : North-West direction */
+#define T1_SIG_N 0x0010		/**< Context orientation : North direction */
+#define T1_SIG_E 0x0020		/**< Context orientation : East direction */
+#define T1_SIG_S 0x0040		/**< Context orientation : South direction */
+#define T1_SIG_W 0x0080		/**< Context orientation : West direction */
+#define T1_SIG_OTH (T1_SIG_N|T1_SIG_NE|T1_SIG_E|T1_SIG_SE|T1_SIG_S|T1_SIG_SW|T1_SIG_W|T1_SIG_NW)
+#define T1_SIG_PRIM (T1_SIG_N|T1_SIG_E|T1_SIG_S|T1_SIG_W)
+
+#define T1_SGN_N 0x0100
+#define T1_SGN_E 0x0200
+#define T1_SGN_S 0x0400
+#define T1_SGN_W 0x0800
+#define T1_SGN (T1_SGN_N|T1_SGN_E|T1_SGN_S|T1_SGN_W)
+
+#define T1_SIG 0x1000
+#define T1_REFINE 0x2000
+#define T1_VISIT 0x4000
+
+#define T1_NUMCTXS_ZC 9
+#define T1_NUMCTXS_SC 5
+#define T1_NUMCTXS_MAG 3
+#define T1_NUMCTXS_AGG 1
+#define T1_NUMCTXS_UNI 1
+
+#define T1_CTXNO_ZC 0
+#define T1_CTXNO_SC (T1_CTXNO_ZC+T1_NUMCTXS_ZC)
+#define T1_CTXNO_MAG (T1_CTXNO_SC+T1_NUMCTXS_SC)
+#define T1_CTXNO_AGG (T1_CTXNO_MAG+T1_NUMCTXS_MAG)
+#define T1_CTXNO_UNI (T1_CTXNO_AGG+T1_NUMCTXS_AGG)
+#define T1_NUMCTXS (T1_CTXNO_UNI+T1_NUMCTXS_UNI)
+
+#define T1_NMSEDEC_FRACBITS (T1_NMSEDEC_BITS-1)
+
+#define T1_TYPE_MQ 0	/**< Normal coding using entropy coder */
+#define T1_TYPE_RAW 1	/**< No encoding the information is store under raw format in codestream (mode switch RAW)*/
+
+/* ----------------------------------------------------------------------- */
+
+typedef short flag_t;
+
+/**
+Tier-1 coding (coding of code-block coefficients)
+*/
+typedef struct opj_t1 {
+	/** codec context */
+	opj_common_ptr cinfo;
+
+	/** MQC component */
+	opj_mqc_t *mqc;
+	/** RAW component */
+	opj_raw_t *raw;
+
+	int *data;
+	flag_t *flags;
+	int w;
+	int h;
+	int datasize;
+	int flagssize;
+	int flags_stride;
+} opj_t1_t;
+
+#define MACRO_t1_flags(x,y) t1->flags[((x)*(t1->flags_stride))+(y)]
+
+/** @name Exported functions */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+/**
+Create a new T1 handle 
+and initialize the look-up tables of the Tier-1 coder/decoder
+@return Returns a new T1 handle if successful, returns NULL otherwise
+@see t1_init_luts
+*/
+opj_t1_t* t1_create(opj_common_ptr cinfo);
+/**
+Destroy a previously created T1 handle
+@param t1 T1 handle to destroy
+*/
+void t1_destroy(opj_t1_t *t1);
+/**
+Encode the code-blocks of a tile
+@param t1 T1 handle
+@param tile The tile to encode
+@param tcp Tile coding parameters
+*/
+void t1_encode_cblks(opj_t1_t *t1, opj_tcd_tile_t *tile, opj_tcp_t *tcp);
+/**
+Decode the code-blocks of a tile
+@param t1 T1 handle
+@param tilec The tile to decode
+@param tccp Tile coding parameters
+*/
+void t1_decode_cblks(opj_t1_t* t1, opj_tcd_tilecomp_t* tilec, opj_tccp_t* tccp);
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __T1_H */

src/add-ons/translators/icns/openjpeg/t1_generate_luts.c

@@ -0,0 +1,275 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * Copyright (c) 2007, Callum Lerwick <seg@haxxed.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "opj_includes.h"
+#include <math.h>
+
+static int t1_init_ctxno_zc(int f, int orient) {
+	int h, v, d, n, t, hv;
+	n = 0;
+	h = ((f & T1_SIG_W) != 0) + ((f & T1_SIG_E) != 0);
+	v = ((f & T1_SIG_N) != 0) + ((f & T1_SIG_S) != 0);
+	d = ((f & T1_SIG_NW) != 0) + ((f & T1_SIG_NE) != 0) + ((f & T1_SIG_SE) != 0) + ((f & T1_SIG_SW) != 0);
+
+	switch (orient) {
+		case 2:
+			t = h;
+			h = v;
+			v = t;
+		case 0:
+		case 1:
+			if (!h) {
+				if (!v) {
+					if (!d)
+						n = 0;
+					else if (d == 1)
+						n = 1;
+					else
+						n = 2;
+				} else if (v == 1) {
+					n = 3;
+				} else {
+					n = 4;
+				}
+			} else if (h == 1) {
+				if (!v) {
+					if (!d)
+						n = 5;
+					else
+						n = 6;
+				} else {
+					n = 7;
+				}
+			} else
+				n = 8;
+			break;
+		case 3:
+			hv = h + v;
+			if (!d) {
+				if (!hv) {
+					n = 0;
+				} else if (hv == 1) {
+					n = 1;
+				} else {
+					n = 2;
+				}
+			} else if (d == 1) {
+				if (!hv) {
+					n = 3;
+				} else if (hv == 1) {
+					n = 4;
+				} else {
+					n = 5;
+				}
+			} else if (d == 2) {
+				if (!hv) {
+					n = 6;
+				} else {
+					n = 7;
+				}
+			} else {
+				n = 8;
+			}
+			break;
+	}
+
+	return (T1_CTXNO_ZC + n);
+}
+
+static int t1_init_ctxno_sc(int f) {
+	int hc, vc, n;
+	n = 0;
+
+	hc = int_min(((f & (T1_SIG_E | T1_SGN_E)) ==
+				T1_SIG_E) + ((f & (T1_SIG_W | T1_SGN_W)) == T1_SIG_W),
+			1) - int_min(((f & (T1_SIG_E | T1_SGN_E)) ==
+					(T1_SIG_E | T1_SGN_E)) +
+				((f & (T1_SIG_W | T1_SGN_W)) ==
+				 (T1_SIG_W | T1_SGN_W)), 1);
+
+	vc = int_min(((f & (T1_SIG_N | T1_SGN_N)) ==
+				T1_SIG_N) + ((f & (T1_SIG_S | T1_SGN_S)) == T1_SIG_S),
+			1) - int_min(((f & (T1_SIG_N | T1_SGN_N)) ==
+					(T1_SIG_N | T1_SGN_N)) +
+				((f & (T1_SIG_S | T1_SGN_S)) ==
+				 (T1_SIG_S | T1_SGN_S)), 1);
+
+	if (hc < 0) {
+		hc = -hc;
+		vc = -vc;
+	}
+	if (!hc) {
+		if (vc == -1)
+			n = 1;
+		else if (!vc)
+			n = 0;
+		else
+			n = 1;
+	} else if (hc == 1) {
+		if (vc == -1)
+			n = 2;
+		else if (!vc)
+			n = 3;
+		else
+			n = 4;
+	}
+
+	return (T1_CTXNO_SC + n);
+}
+
+static int t1_init_spb(int f) {
+	int hc, vc, n;
+
+	hc = int_min(((f & (T1_SIG_E | T1_SGN_E)) ==
+				T1_SIG_E) + ((f & (T1_SIG_W | T1_SGN_W)) == T1_SIG_W),
+			1) - int_min(((f & (T1_SIG_E | T1_SGN_E)) ==
+					(T1_SIG_E | T1_SGN_E)) +
+				((f & (T1_SIG_W | T1_SGN_W)) ==
+				 (T1_SIG_W | T1_SGN_W)), 1);
+
+	vc = int_min(((f & (T1_SIG_N | T1_SGN_N)) ==
+				T1_SIG_N) + ((f & (T1_SIG_S | T1_SGN_S)) == T1_SIG_S),
+			1) - int_min(((f & (T1_SIG_N | T1_SGN_N)) ==
+					(T1_SIG_N | T1_SGN_N)) +
+				((f & (T1_SIG_S | T1_SGN_S)) ==
+				 (T1_SIG_S | T1_SGN_S)), 1);
+
+	if (!hc && !vc)
+		n = 0;
+	else
+		n = (!(hc > 0 || (!hc && vc > 0)));
+
+	return n;
+}
+
+void dump_array16(int array[],int size){
+	int i;
+	--size;
+	for (i = 0; i < size; ++i) {
+		printf("0x%04x, ", array[i]);
+		if(!((i+1)&0x7))
+			printf("\n  ");
+	}
+	printf("0x%04x\n};\n\n", array[size]);
+}
+
+int main(){
+	int i, j;
+	double u, v, t;
+
+	int lut_ctxno_zc[1024];
+	int lut_nmsedec_sig[1 << T1_NMSEDEC_BITS];
+	int lut_nmsedec_sig0[1 << T1_NMSEDEC_BITS];
+	int lut_nmsedec_ref[1 << T1_NMSEDEC_BITS];
+	int lut_nmsedec_ref0[1 << T1_NMSEDEC_BITS];
+
+	printf("/* This file was automatically generated by t1_generate_luts.c */\n\n");
+
+	// lut_ctxno_zc
+	for (j = 0; j < 4; ++j) {
+		for (i = 0; i < 256; ++i) {
+			int orient = j;
+			if (orient == 2) {
+				orient = 1;
+			} else if (orient == 1) {
+				orient = 2;
+			}
+			lut_ctxno_zc[(orient << 8) | i] = t1_init_ctxno_zc(i, j);
+		}
+	}
+
+	printf("static char lut_ctxno_zc[1024] = {\n  ");
+	for (i = 0; i < 1023; ++i) {
+		printf("%i, ", lut_ctxno_zc[i]);
+		if(!((i+1)&0x1f))
+			printf("\n  ");
+	}
+	printf("%i\n};\n\n", lut_ctxno_zc[1023]);
+
+	// lut_ctxno_sc
+	printf("static char lut_ctxno_sc[256] = {\n  ");
+	for (i = 0; i < 255; ++i) {
+		printf("0x%x, ", t1_init_ctxno_sc(i << 4));
+		if(!((i+1)&0xf))
+			printf("\n  ");
+	}
+	printf("0x%x\n};\n\n", t1_init_ctxno_sc(255 << 4));
+
+	// lut_spb
+	printf("static char lut_spb[256] = {\n  ");
+	for (i = 0; i < 255; ++i) {
+		printf("%i, ", t1_init_spb(i << 4));
+		if(!((i+1)&0x1f))
+			printf("\n  ");
+	}
+	printf("%i\n};\n\n", t1_init_spb(255 << 4));
+
+	/* FIXME FIXME FIXME */
+	/* fprintf(stdout,"nmsedec luts:\n"); */
+	for (i = 0; i < (1 << T1_NMSEDEC_BITS); ++i) {
+		t = i / pow(2, T1_NMSEDEC_FRACBITS);
+		u = t;
+		v = t - 1.5;
+		lut_nmsedec_sig[i] = 
+			int_max(0, 
+					(int) (floor((u * u - v * v) * pow(2, T1_NMSEDEC_FRACBITS) + 0.5) / pow(2, T1_NMSEDEC_FRACBITS) * 8192.0));
+		lut_nmsedec_sig0[i] =
+			int_max(0,
+					(int) (floor((u * u) * pow(2, T1_NMSEDEC_FRACBITS) + 0.5) / pow(2, T1_NMSEDEC_FRACBITS) * 8192.0));
+		u = t - 1.0;
+		if (i & (1 << (T1_NMSEDEC_BITS - 1))) {
+			v = t - 1.5;
+		} else {
+			v = t - 0.5;
+		}
+		lut_nmsedec_ref[i] =
+			int_max(0,
+					(int) (floor((u * u - v * v) * pow(2, T1_NMSEDEC_FRACBITS) + 0.5) / pow(2, T1_NMSEDEC_FRACBITS) * 8192.0));
+		lut_nmsedec_ref0[i] =
+			int_max(0,
+					(int) (floor((u * u) * pow(2, T1_NMSEDEC_FRACBITS) + 0.5) / pow(2, T1_NMSEDEC_FRACBITS) * 8192.0));
+	}
+
+	printf("static short lut_nmsedec_sig[1 << T1_NMSEDEC_BITS] = {\n  ");
+	dump_array16(lut_nmsedec_sig, 1 << T1_NMSEDEC_BITS);
+
+	printf("static short lut_nmsedec_sig0[1 << T1_NMSEDEC_BITS] = {\n  ");
+	dump_array16(lut_nmsedec_sig0, 1 << T1_NMSEDEC_BITS);
+
+	printf("static short lut_nmsedec_ref[1 << T1_NMSEDEC_BITS] = {\n  ");
+	dump_array16(lut_nmsedec_ref, 1 << T1_NMSEDEC_BITS);
+
+	printf("static short lut_nmsedec_ref0[1 << T1_NMSEDEC_BITS] = {\n  ");
+	dump_array16(lut_nmsedec_ref0, 1 << T1_NMSEDEC_BITS);
+
+	return 0;
+}

src/add-ons/translators/icns/openjpeg/t1_luts.h

@@ -0,0 +1,143 @@
+/* This file was automatically generated by t1_generate_luts.c */
+
+static char lut_ctxno_zc[1024] = {
+  0, 1, 1, 2, 1, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 
+  5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
+  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
+  7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
+  5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
+  8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+  7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
+  8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+  0, 1, 1, 2, 1, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 
+  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
+  5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+  7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
+  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
+  7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+  7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+  0, 1, 1, 2, 1, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 
+  5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
+  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
+  7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
+  5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
+  8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+  7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
+  8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+  0, 3, 3, 6, 3, 6, 6, 8, 3, 6, 6, 8, 6, 8, 8, 8, 1, 4, 4, 7, 4, 7, 7, 8, 4, 7, 7, 8, 7, 8, 8, 8, 
+  1, 4, 4, 7, 4, 7, 7, 8, 4, 7, 7, 8, 7, 8, 8, 8, 2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8, 
+  1, 4, 4, 7, 4, 7, 7, 8, 4, 7, 7, 8, 7, 8, 8, 8, 2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8, 
+  2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8, 2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8, 
+  1, 4, 4, 7, 4, 7, 7, 8, 4, 7, 7, 8, 7, 8, 8, 8, 2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8, 
+  2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8, 2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8, 
+  2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8, 2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8, 
+  2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8, 2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8
+};
+
+static char lut_ctxno_sc[256] = {
+  0x9, 0xa, 0xc, 0xd, 0xa, 0xa, 0xd, 0xd, 0xc, 0xd, 0xc, 0xd, 0xd, 0xd, 0xd, 0xd, 
+  0x9, 0xa, 0xc, 0xb, 0xa, 0x9, 0xd, 0xc, 0xc, 0xb, 0xc, 0xb, 0xd, 0xc, 0xd, 0xc, 
+  0x9, 0xa, 0xc, 0xb, 0xa, 0xa, 0xb, 0xb, 0xc, 0xd, 0x9, 0xa, 0xd, 0xd, 0xa, 0xa, 
+  0x9, 0xa, 0xc, 0xd, 0xa, 0x9, 0xb, 0xc, 0xc, 0xb, 0x9, 0xa, 0xd, 0xc, 0xa, 0x9, 
+  0x9, 0xa, 0xc, 0xd, 0xa, 0x9, 0xb, 0xc, 0xc, 0xd, 0xc, 0xd, 0xb, 0xc, 0xb, 0xc, 
+  0x9, 0xa, 0xc, 0xb, 0xa, 0xa, 0xb, 0xb, 0xc, 0xb, 0xc, 0xb, 0xb, 0xb, 0xb, 0xb, 
+  0x9, 0xa, 0xc, 0xb, 0xa, 0x9, 0xd, 0xc, 0xc, 0xd, 0x9, 0xa, 0xb, 0xc, 0xa, 0x9, 
+  0x9, 0xa, 0xc, 0xd, 0xa, 0xa, 0xd, 0xd, 0xc, 0xb, 0x9, 0xa, 0xb, 0xb, 0xa, 0xa, 
+  0x9, 0xa, 0xc, 0xd, 0xa, 0xa, 0xd, 0xd, 0xc, 0xb, 0x9, 0xa, 0xb, 0xb, 0xa, 0xa, 
+  0x9, 0xa, 0xc, 0xb, 0xa, 0x9, 0xd, 0xc, 0xc, 0xd, 0x9, 0xa, 0xb, 0xc, 0xa, 0x9, 
+  0x9, 0xa, 0xc, 0xb, 0xa, 0xa, 0xb, 0xb, 0xc, 0xb, 0xc, 0xb, 0xb, 0xb, 0xb, 0xb, 
+  0x9, 0xa, 0xc, 0xd, 0xa, 0x9, 0xb, 0xc, 0xc, 0xd, 0xc, 0xd, 0xb, 0xc, 0xb, 0xc, 
+  0x9, 0xa, 0xc, 0xd, 0xa, 0x9, 0xb, 0xc, 0xc, 0xb, 0x9, 0xa, 0xd, 0xc, 0xa, 0x9, 
+  0x9, 0xa, 0xc, 0xb, 0xa, 0xa, 0xb, 0xb, 0xc, 0xd, 0x9, 0xa, 0xd, 0xd, 0xa, 0xa, 
+  0x9, 0xa, 0xc, 0xb, 0xa, 0x9, 0xd, 0xc, 0xc, 0xb, 0xc, 0xb, 0xd, 0xc, 0xd, 0xc, 
+  0x9, 0xa, 0xc, 0xd, 0xa, 0xa, 0xd, 0xd, 0xc, 0xd, 0xc, 0xd, 0xd, 0xd, 0xd, 0xd
+};
+
+static char lut_spb[256] = {
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 
+  0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 
+  0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 
+  0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
+  0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 
+  0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
+};
+
+static short lut_nmsedec_sig[1 << T1_NMSEDEC_BITS] = {
+  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
+  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
+  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
+  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
+  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
+  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
+  0x0000, 0x0180, 0x0300, 0x0480, 0x0600, 0x0780, 0x0900, 0x0a80, 
+  0x0c00, 0x0d80, 0x0f00, 0x1080, 0x1200, 0x1380, 0x1500, 0x1680, 
+  0x1800, 0x1980, 0x1b00, 0x1c80, 0x1e00, 0x1f80, 0x2100, 0x2280, 
+  0x2400, 0x2580, 0x2700, 0x2880, 0x2a00, 0x2b80, 0x2d00, 0x2e80, 
+  0x3000, 0x3180, 0x3300, 0x3480, 0x3600, 0x3780, 0x3900, 0x3a80, 
+  0x3c00, 0x3d80, 0x3f00, 0x4080, 0x4200, 0x4380, 0x4500, 0x4680, 
+  0x4800, 0x4980, 0x4b00, 0x4c80, 0x4e00, 0x4f80, 0x5100, 0x5280, 
+  0x5400, 0x5580, 0x5700, 0x5880, 0x5a00, 0x5b80, 0x5d00, 0x5e80, 
+  0x6000, 0x6180, 0x6300, 0x6480, 0x6600, 0x6780, 0x6900, 0x6a80, 
+  0x6c00, 0x6d80, 0x6f00, 0x7080, 0x7200, 0x7380, 0x7500, 0x7680
+};
+
+static short lut_nmsedec_sig0[1 << T1_NMSEDEC_BITS] = {
+  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0080, 0x0080, 
+  0x0080, 0x0080, 0x0100, 0x0100, 0x0100, 0x0180, 0x0180, 0x0200, 
+  0x0200, 0x0280, 0x0280, 0x0300, 0x0300, 0x0380, 0x0400, 0x0400, 
+  0x0480, 0x0500, 0x0580, 0x0580, 0x0600, 0x0680, 0x0700, 0x0780, 
+  0x0800, 0x0880, 0x0900, 0x0980, 0x0a00, 0x0a80, 0x0b80, 0x0c00, 
+  0x0c80, 0x0d00, 0x0e00, 0x0e80, 0x0f00, 0x1000, 0x1080, 0x1180, 
+  0x1200, 0x1300, 0x1380, 0x1480, 0x1500, 0x1600, 0x1700, 0x1780, 
+  0x1880, 0x1980, 0x1a80, 0x1b00, 0x1c00, 0x1d00, 0x1e00, 0x1f00, 
+  0x2000, 0x2100, 0x2200, 0x2300, 0x2400, 0x2500, 0x2680, 0x2780, 
+  0x2880, 0x2980, 0x2b00, 0x2c00, 0x2d00, 0x2e80, 0x2f80, 0x3100, 
+  0x3200, 0x3380, 0x3480, 0x3600, 0x3700, 0x3880, 0x3a00, 0x3b00, 
+  0x3c80, 0x3e00, 0x3f80, 0x4080, 0x4200, 0x4380, 0x4500, 0x4680, 
+  0x4800, 0x4980, 0x4b00, 0x4c80, 0x4e00, 0x4f80, 0x5180, 0x5300, 
+  0x5480, 0x5600, 0x5800, 0x5980, 0x5b00, 0x5d00, 0x5e80, 0x6080, 
+  0x6200, 0x6400, 0x6580, 0x6780, 0x6900, 0x6b00, 0x6d00, 0x6e80, 
+  0x7080, 0x7280, 0x7480, 0x7600, 0x7800, 0x7a00, 0x7c00, 0x7e00
+};
+
+static short lut_nmsedec_ref[1 << T1_NMSEDEC_BITS] = {
+  0x1800, 0x1780, 0x1700, 0x1680, 0x1600, 0x1580, 0x1500, 0x1480, 
+  0x1400, 0x1380, 0x1300, 0x1280, 0x1200, 0x1180, 0x1100, 0x1080, 
+  0x1000, 0x0f80, 0x0f00, 0x0e80, 0x0e00, 0x0d80, 0x0d00, 0x0c80, 
+  0x0c00, 0x0b80, 0x0b00, 0x0a80, 0x0a00, 0x0980, 0x0900, 0x0880, 
+  0x0800, 0x0780, 0x0700, 0x0680, 0x0600, 0x0580, 0x0500, 0x0480, 
+  0x0400, 0x0380, 0x0300, 0x0280, 0x0200, 0x0180, 0x0100, 0x0080, 
+  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
+  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
+  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
+  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
+  0x0000, 0x0080, 0x0100, 0x0180, 0x0200, 0x0280, 0x0300, 0x0380, 
+  0x0400, 0x0480, 0x0500, 0x0580, 0x0600, 0x0680, 0x0700, 0x0780, 
+  0x0800, 0x0880, 0x0900, 0x0980, 0x0a00, 0x0a80, 0x0b00, 0x0b80, 
+  0x0c00, 0x0c80, 0x0d00, 0x0d80, 0x0e00, 0x0e80, 0x0f00, 0x0f80, 
+  0x1000, 0x1080, 0x1100, 0x1180, 0x1200, 0x1280, 0x1300, 0x1380, 
+  0x1400, 0x1480, 0x1500, 0x1580, 0x1600, 0x1680, 0x1700, 0x1780
+};
+
+static short lut_nmsedec_ref0[1 << T1_NMSEDEC_BITS] = {
+  0x2000, 0x1f00, 0x1e00, 0x1d00, 0x1c00, 0x1b00, 0x1a80, 0x1980, 
+  0x1880, 0x1780, 0x1700, 0x1600, 0x1500, 0x1480, 0x1380, 0x1300, 
+  0x1200, 0x1180, 0x1080, 0x1000, 0x0f00, 0x0e80, 0x0e00, 0x0d00, 
+  0x0c80, 0x0c00, 0x0b80, 0x0a80, 0x0a00, 0x0980, 0x0900, 0x0880, 
+  0x0800, 0x0780, 0x0700, 0x0680, 0x0600, 0x0580, 0x0580, 0x0500, 
+  0x0480, 0x0400, 0x0400, 0x0380, 0x0300, 0x0300, 0x0280, 0x0280, 
+  0x0200, 0x0200, 0x0180, 0x0180, 0x0100, 0x0100, 0x0100, 0x0080, 
+  0x0080, 0x0080, 0x0080, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
+  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0080, 0x0080, 
+  0x0080, 0x0080, 0x0100, 0x0100, 0x0100, 0x0180, 0x0180, 0x0200, 
+  0x0200, 0x0280, 0x0280, 0x0300, 0x0300, 0x0380, 0x0400, 0x0400, 
+  0x0480, 0x0500, 0x0580, 0x0580, 0x0600, 0x0680, 0x0700, 0x0780, 
+  0x0800, 0x0880, 0x0900, 0x0980, 0x0a00, 0x0a80, 0x0b80, 0x0c00, 
+  0x0c80, 0x0d00, 0x0e00, 0x0e80, 0x0f00, 0x1000, 0x1080, 0x1180, 
+  0x1200, 0x1300, 0x1380, 0x1480, 0x1500, 0x1600, 0x1700, 0x1780, 
+  0x1880, 0x1980, 0x1a80, 0x1b00, 0x1c00, 0x1d00, 0x1e00, 0x1f00
+};
+

src/add-ons/translators/icns/openjpeg/t2.c

@@ -0,0 +1,822 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "opj_includes.h"
+
+/** @defgroup T2 T2 - Implementation of a tier-2 coding */
+/*@{*/
+
+/** @name Local static functions */
+/*@{*/
+
+static void t2_putcommacode(opj_bio_t *bio, int n);
+static int t2_getcommacode(opj_bio_t *bio);
+/**
+Variable length code for signalling delta Zil (truncation point)
+@param bio Bit Input/Output component
+@param n delta Zil
+*/
+static void t2_putnumpasses(opj_bio_t *bio, int n);
+static int t2_getnumpasses(opj_bio_t *bio);
+/**
+Encode a packet of a tile to a destination buffer
+@param tile Tile for which to write the packets
+@param tcp Tile coding parameters
+@param pi Packet identity
+@param dest Destination buffer
+@param len Length of the destination buffer
+@param cstr_info Codestream information structure 
+@param tileno Number of the tile encoded
+@return 
+*/
+static int t2_encode_packet(opj_tcd_tile_t *tile, opj_tcp_t *tcp, opj_pi_iterator_t *pi, unsigned char *dest, int len, opj_codestream_info_t *cstr_info, int tileno);
+/**
+@param cblk
+@param index
+@param cblksty
+@param first
+*/
+static opj_bool t2_init_seg(opj_tcd_cblk_dec_t* cblk, int index, int cblksty, int first);
+/**
+Decode a packet of a tile from a source buffer
+@param t2 T2 handle
+@param src Source buffer
+@param len Length of the source buffer
+@param tile Tile for which to write the packets
+@param tcp Tile coding parameters
+@param pi Packet identity
+@param pack_info Packet information
+@return 
+*/
+static int t2_decode_packet(opj_t2_t* t2, unsigned char *src, int len, opj_tcd_tile_t *tile, 
+														opj_tcp_t *tcp, opj_pi_iterator_t *pi, opj_packet_info_t *pack_info);
+
+/*@}*/
+
+/*@}*/
+
+/* ----------------------------------------------------------------------- */
+
+/* #define RESTART 0x04 */
+
+static void t2_putcommacode(opj_bio_t *bio, int n) {
+	while (--n >= 0) {
+		bio_write(bio, 1, 1);
+	}
+	bio_write(bio, 0, 1);
+}
+
+static int t2_getcommacode(opj_bio_t *bio) {
+	int n;
+	for (n = 0; bio_read(bio, 1); n++) {
+		;
+	}
+	return n;
+}
+
+static void t2_putnumpasses(opj_bio_t *bio, int n) {
+	if (n == 1) {
+		bio_write(bio, 0, 1);
+	} else if (n == 2) {
+		bio_write(bio, 2, 2);
+	} else if (n <= 5) {
+		bio_write(bio, 0xc | (n - 3), 4);
+	} else if (n <= 36) {
+		bio_write(bio, 0x1e0 | (n - 6), 9);
+	} else if (n <= 164) {
+		bio_write(bio, 0xff80 | (n - 37), 16);
+	}
+}
+
+static int t2_getnumpasses(opj_bio_t *bio) {
+	int n;
+	if (!bio_read(bio, 1))
+		return 1;
+	if (!bio_read(bio, 1))
+		return 2;
+	if ((n = bio_read(bio, 2)) != 3)
+		return (3 + n);
+	if ((n = bio_read(bio, 5)) != 31)
+		return (6 + n);
+	return (37 + bio_read(bio, 7));
+}
+
+static int t2_encode_packet(opj_tcd_tile_t * tile, opj_tcp_t * tcp, opj_pi_iterator_t *pi, unsigned char *dest, int length, opj_codestream_info_t *cstr_info, int tileno) {
+	int bandno, cblkno;
+	unsigned char *c = dest;
+
+	int compno = pi->compno;	/* component value */
+	int resno  = pi->resno;		/* resolution level value */
+	int precno = pi->precno;	/* precinct value */
+	int layno  = pi->layno;		/* quality layer value */
+
+	opj_tcd_tilecomp_t *tilec = &tile->comps[compno];
+	opj_tcd_resolution_t *res = &tilec->resolutions[resno];
+	
+	opj_bio_t *bio = NULL;	/* BIO component */
+	
+	/* <SOP 0xff91> */
+	if (tcp->csty & J2K_CP_CSTY_SOP) {
+		c[0] = 255;
+		c[1] = 145;
+		c[2] = 0;
+		c[3] = 4;
+		c[4] = (unsigned char)((tile->packno % 65536) / 256);
+		c[5] = (unsigned char)((tile->packno % 65536) % 256);
+		c += 6;
+	}
+	/* </SOP> */
+	
+	if (!layno) {
+		for (bandno = 0; bandno < res->numbands; bandno++) {
+			opj_tcd_band_t *band = &res->bands[bandno];
+			opj_tcd_precinct_t *prc = &band->precincts[precno];
+			tgt_reset(prc->incltree);
+			tgt_reset(prc->imsbtree);
+			for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
+				opj_tcd_cblk_enc_t* cblk = &prc->cblks.enc[cblkno];
+				cblk->numpasses = 0;
+				tgt_setvalue(prc->imsbtree, cblkno, band->numbps - cblk->numbps);
+			}
+		}
+	}
+	
+	bio = bio_create();
+	bio_init_enc(bio, c, length);
+	bio_write(bio, 1, 1);		/* Empty header bit */
+	
+	/* Writing Packet header */
+	for (bandno = 0; bandno < res->numbands; bandno++) {
+		opj_tcd_band_t *band = &res->bands[bandno];
+		opj_tcd_precinct_t *prc = &band->precincts[precno];
+		for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
+			opj_tcd_cblk_enc_t* cblk = &prc->cblks.enc[cblkno];
+			opj_tcd_layer_t *layer = &cblk->layers[layno];
+			if (!cblk->numpasses && layer->numpasses) {
+				tgt_setvalue(prc->incltree, cblkno, layno);
+			}
+		}
+		for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
+			opj_tcd_cblk_enc_t* cblk = &prc->cblks.enc[cblkno];
+			opj_tcd_layer_t *layer = &cblk->layers[layno];
+			int increment = 0;
+			int nump = 0;
+			int len = 0, passno;
+			/* cblk inclusion bits */
+			if (!cblk->numpasses) {
+				tgt_encode(bio, prc->incltree, cblkno, layno + 1);
+			} else {
+				bio_write(bio, layer->numpasses != 0, 1);
+			}
+			/* if cblk not included, go to the next cblk  */
+			if (!layer->numpasses) {
+				continue;
+			}
+			/* if first instance of cblk --> zero bit-planes information */
+			if (!cblk->numpasses) {
+				cblk->numlenbits = 3;
+				tgt_encode(bio, prc->imsbtree, cblkno, 999);
+			}
+			/* number of coding passes included */
+			t2_putnumpasses(bio, layer->numpasses);
+			
+			/* computation of the increase of the length indicator and insertion in the header     */
+			for (passno = cblk->numpasses; passno < cblk->numpasses + layer->numpasses; passno++) {
+				opj_tcd_pass_t *pass = &cblk->passes[passno];
+				nump++;
+				len += pass->len;
+				if (pass->term || passno == (cblk->numpasses + layer->numpasses) - 1) {
+					increment = int_max(increment, int_floorlog2(len) + 1 - (cblk->numlenbits + int_floorlog2(nump)));
+					len = 0;
+					nump = 0;
+				}
+			}
+			t2_putcommacode(bio, increment);
+
+			/* computation of the new Length indicator */
+			cblk->numlenbits += increment;
+
+			/* insertion of the codeword segment length */
+			for (passno = cblk->numpasses; passno < cblk->numpasses + layer->numpasses; passno++) {
+				opj_tcd_pass_t *pass = &cblk->passes[passno];
+				nump++;
+				len += pass->len;
+				if (pass->term || passno == (cblk->numpasses + layer->numpasses) - 1) {
+					bio_write(bio, len, cblk->numlenbits + int_floorlog2(nump));
+					len = 0;
+					nump = 0;
+				}
+			}
+		}
+	}
+
+	if (bio_flush(bio)) {
+		bio_destroy(bio);
+		return -999;		/* modified to eliminate longjmp !! */
+	}
+
+	c += bio_numbytes(bio);
+	bio_destroy(bio);
+	
+	/* <EPH 0xff92> */
+	if (tcp->csty & J2K_CP_CSTY_EPH) {
+		c[0] = 255;
+		c[1] = 146;
+		c += 2;
+	}
+	/* </EPH> */
+
+	/* << INDEX */
+	/* End of packet header position. Currently only represents the distance to start of packet
+	// Will be updated later by incrementing with packet start value */
+	if(cstr_info && cstr_info->index_write) {
+		opj_packet_info_t *info_PK = &cstr_info->tile[tileno].packet[cstr_info->packno];
+		info_PK->end_ph_pos = (int)(c - dest);
+	}
+	/* INDEX >> */
+	
+	/* Writing the packet body */
+	
+	for (bandno = 0; bandno < res->numbands; bandno++) {
+		opj_tcd_band_t *band = &res->bands[bandno];
+		opj_tcd_precinct_t *prc = &band->precincts[precno];
+		for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
+			opj_tcd_cblk_enc_t* cblk = &prc->cblks.enc[cblkno];
+			opj_tcd_layer_t *layer = &cblk->layers[layno];
+			if (!layer->numpasses) {
+				continue;
+			}
+			if (c + layer->len > dest + length) {
+				return -999;
+			}
+			
+			memcpy(c, layer->data, layer->len);
+			cblk->numpasses += layer->numpasses;
+			c += layer->len;
+			/* << INDEX */ 
+			if(cstr_info && cstr_info->index_write) {
+				opj_packet_info_t *info_PK = &cstr_info->tile[tileno].packet[cstr_info->packno];
+				info_PK->disto += layer->disto;
+				if (cstr_info->D_max < info_PK->disto) {
+					cstr_info->D_max = info_PK->disto;
+				}
+			}
+			/* INDEX >> */
+		}
+	}
+	
+	return (c - dest);
+}
+
+static opj_bool t2_init_seg(opj_tcd_cblk_dec_t* cblk, int index, int cblksty, int first) {
+	opj_tcd_seg_t* seg;
+    opj_tcd_seg_t* segs;
+    segs = (opj_tcd_seg_t*) opj_realloc(cblk->segs, (index + 1) * sizeof(opj_tcd_seg_t));
+
+    if (segs == NULL)
+    {
+        return OPJ_FALSE;
+    }
+    cblk->segs = segs;
+
+	seg = &cblk->segs[index];
+	seg->data = NULL;
+	seg->dataindex = 0;
+	seg->numpasses = 0;
+	seg->len = 0;
+	if (cblksty & J2K_CCP_CBLKSTY_TERMALL) {
+		seg->maxpasses = 1;
+	}
+	else if (cblksty & J2K_CCP_CBLKSTY_LAZY) {
+		if (first) {
+			seg->maxpasses = 10;
+		} else {
+			seg->maxpasses = (((seg - 1)->maxpasses == 1) || ((seg - 1)->maxpasses == 10)) ? 2 : 1;
+		}
+	} else {
+		seg->maxpasses = 109;
+	}
+
+    return OPJ_TRUE;
+}
+
+static int t2_decode_packet(opj_t2_t* t2, unsigned char *src, int len, opj_tcd_tile_t *tile, 
+														opj_tcp_t *tcp, opj_pi_iterator_t *pi, opj_packet_info_t *pack_info) {
+	int bandno, cblkno;
+	unsigned char *c = src;
+
+	opj_cp_t *cp = t2->cp;
+
+	int compno = pi->compno;	/* component value */
+	int resno  = pi->resno;		/* resolution level value */
+	int precno = pi->precno;	/* precinct value */
+	int layno  = pi->layno;		/* quality layer value */
+
+	opj_tcd_resolution_t* res = &tile->comps[compno].resolutions[resno];
+
+	unsigned char *hd = NULL;
+	int present;
+	
+	opj_bio_t *bio = NULL;	/* BIO component */
+	
+	if (layno == 0) {
+		for (bandno = 0; bandno < res->numbands; bandno++) {
+			opj_tcd_band_t *band = &res->bands[bandno];
+			opj_tcd_precinct_t *prc = &band->precincts[precno];
+			
+			if ((band->x1-band->x0 == 0)||(band->y1-band->y0 == 0)) continue;
+			
+			tgt_reset(prc->incltree);
+			tgt_reset(prc->imsbtree);
+			for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
+				opj_tcd_cblk_dec_t* cblk = &prc->cblks.dec[cblkno];
+				cblk->numsegs = 0;
+			}
+		}
+	}
+	
+	/* SOP markers */
+	
+	if (tcp->csty & J2K_CP_CSTY_SOP) {
+		if ((*c) != 0xff || (*(c + 1) != 0x91)) {
+			opj_event_msg(t2->cinfo, EVT_WARNING, "Expected SOP marker\n");
+		} else {
+			c += 6;
+		}
+		
+		/** TODO : check the Nsop value */
+	}
+	
+	/* 
+	When the marker PPT/PPM is used the packet header are store in PPT/PPM marker
+	This part deal with this caracteristic
+	step 1: Read packet header in the saved structure
+	step 2: Return to codestream for decoding 
+	*/
+
+	bio = bio_create();
+	
+	if (cp->ppm == 1) {		/* PPM */
+		hd = cp->ppm_data;
+		bio_init_dec(bio, hd, cp->ppm_len);
+	} else if (tcp->ppt == 1) {	/* PPT */
+		hd = tcp->ppt_data;
+		bio_init_dec(bio, hd, tcp->ppt_len);
+	} else {			/* Normal Case */
+		hd = c;
+		bio_init_dec(bio, hd, src+len-hd);
+	}
+	
+	present = bio_read(bio, 1);
+	
+	if (!present) {
+		bio_inalign(bio);
+		hd += bio_numbytes(bio);
+		bio_destroy(bio);
+		
+		/* EPH markers */
+		
+		if (tcp->csty & J2K_CP_CSTY_EPH) {
+			if ((*hd) != 0xff || (*(hd + 1) != 0x92)) {
+				printf("Error : expected EPH marker\n");
+			} else {
+				hd += 2;
+			}
+		}
+
+		/* << INDEX */
+		/* End of packet header position. Currently only represents the distance to start of packet
+		// Will be updated later by incrementing with packet start value*/
+		if(pack_info) {
+			pack_info->end_ph_pos = (int)(c - src);
+		}
+		/* INDEX >> */
+		
+		if (cp->ppm == 1) {		/* PPM case */
+			cp->ppm_len += cp->ppm_data-hd;
+			cp->ppm_data = hd;
+			return (c - src);
+		}
+		if (tcp->ppt == 1) {	/* PPT case */
+			tcp->ppt_len+=tcp->ppt_data-hd;
+			tcp->ppt_data = hd;
+			return (c - src);
+		}
+		
+		return (hd - src);
+	}
+	
+	for (bandno = 0; bandno < res->numbands; bandno++) {
+		opj_tcd_band_t *band = &res->bands[bandno];
+		opj_tcd_precinct_t *prc = &band->precincts[precno];
+		
+		if ((band->x1-band->x0 == 0)||(band->y1-band->y0 == 0)) continue;
+		
+		for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
+			int included, increment, n, segno;
+			opj_tcd_cblk_dec_t* cblk = &prc->cblks.dec[cblkno];
+			/* if cblk not yet included before --> inclusion tagtree */
+			if (!cblk->numsegs) {
+				included = tgt_decode(bio, prc->incltree, cblkno, layno + 1);
+				/* else one bit */
+			} else {
+				included = bio_read(bio, 1);
+			}
+			/* if cblk not included */
+			if (!included) {
+				cblk->numnewpasses = 0;
+				continue;
+			}
+			/* if cblk not yet included --> zero-bitplane tagtree */
+			if (!cblk->numsegs) {
+				int i, numimsbs;
+				for (i = 0; !tgt_decode(bio, prc->imsbtree, cblkno, i); i++) {
+					;
+				}
+				numimsbs = i - 1;
+				cblk->numbps = band->numbps - numimsbs;
+				cblk->numlenbits = 3;
+			}
+			/* number of coding passes */
+			cblk->numnewpasses = t2_getnumpasses(bio);
+			increment = t2_getcommacode(bio);
+			/* length indicator increment */
+			cblk->numlenbits += increment;
+			segno = 0;
+			if (!cblk->numsegs) {
+                if (!t2_init_seg(cblk, segno, tcp->tccps[compno].cblksty, 1))
+                {
+                    opj_event_msg(t2->cinfo, EVT_ERROR, "Out of memory\n");
+                    bio_destroy(bio);
+                    return -999;
+                }
+			} else {
+				segno = cblk->numsegs - 1;
+				if (cblk->segs[segno].numpasses == cblk->segs[segno].maxpasses) {
+					++segno;
+                    if (!t2_init_seg(cblk, segno, tcp->tccps[compno].cblksty, 0))
+                    {
+                        opj_event_msg(t2->cinfo, EVT_ERROR, "Out of memory\n");
+                        bio_destroy(bio);
+                        return -999;
+                    }
+				}
+			}
+			n = cblk->numnewpasses;
+			
+			do {
+				cblk->segs[segno].numnewpasses = int_min(cblk->segs[segno].maxpasses - cblk->segs[segno].numpasses, n);
+				cblk->segs[segno].newlen = bio_read(bio, cblk->numlenbits + int_floorlog2(cblk->segs[segno].numnewpasses));
+				n -= cblk->segs[segno].numnewpasses;
+				if (n > 0) {
+					++segno;
+                    if (!t2_init_seg(cblk, segno, tcp->tccps[compno].cblksty, 0))
+                    {
+                        opj_event_msg(t2->cinfo, EVT_ERROR, "Out of memory\n");
+                        bio_destroy(bio);
+                        return -999;
+                    }
+				}
+			} while (n > 0);
+		}
+	}
+	
+	if (bio_inalign(bio)) {
+		bio_destroy(bio);
+		return -999;
+	}
+	
+	hd += bio_numbytes(bio);
+	bio_destroy(bio);
+	
+	/* EPH markers */
+	if (tcp->csty & J2K_CP_CSTY_EPH) {
+		if ((*hd) != 0xff || (*(hd + 1) != 0x92)) {
+			opj_event_msg(t2->cinfo, EVT_ERROR, "Expected EPH marker\n");
+			return -999;
+		} else {
+			hd += 2;
+		}
+	}
+
+	/* << INDEX */
+	/* End of packet header position. Currently only represents the distance to start of packet
+	// Will be updated later by incrementing with packet start value*/
+	if(pack_info) {
+		pack_info->end_ph_pos = (int)(hd - src);
+	}
+	/* INDEX >> */
+	
+	if (cp->ppm==1) {
+		cp->ppm_len+=cp->ppm_data-hd;
+		cp->ppm_data = hd;
+	} else if (tcp->ppt == 1) {
+		tcp->ppt_len+=tcp->ppt_data-hd;
+		tcp->ppt_data = hd;
+	} else {
+		c=hd;
+	}
+	
+	for (bandno = 0; bandno < res->numbands; bandno++) {
+		opj_tcd_band_t *band = &res->bands[bandno];
+		opj_tcd_precinct_t *prc = &band->precincts[precno];
+		
+		if ((band->x1-band->x0 == 0)||(band->y1-band->y0 == 0)) continue;
+		
+		for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
+			opj_tcd_cblk_dec_t* cblk = &prc->cblks.dec[cblkno];
+			opj_tcd_seg_t *seg = NULL;
+			if (!cblk->numnewpasses)
+				continue;
+			if (!cblk->numsegs) {
+				seg = &cblk->segs[0];
+				cblk->numsegs++;
+				cblk->len = 0;
+			} else {
+				seg = &cblk->segs[cblk->numsegs - 1];
+				if (seg->numpasses == seg->maxpasses) {
+					seg++;
+					cblk->numsegs++;
+				}
+			}
+			
+			do {
+				if (c + seg->newlen > src + len) {
+					return -999;
+				}
+
+#ifdef USE_JPWL
+			/* we need here a j2k handle to verify if making a check to
+			the validity of cblocks parameters is selected from user (-W) */
+
+				/* let's check that we are not exceeding */
+				if ((cblk->len + seg->newlen) > 8192) {
+					opj_event_msg(t2->cinfo, EVT_WARNING,
+						"JPWL: segment too long (%d) for codeblock %d (p=%d, b=%d, r=%d, c=%d)\n",
+						seg->newlen, cblkno, precno, bandno, resno, compno);
+					if (!JPWL_ASSUME) {
+						opj_event_msg(t2->cinfo, EVT_ERROR, "JPWL: giving up\n");
+						return -999;
+					}
+					seg->newlen = 8192 - cblk->len;
+					opj_event_msg(t2->cinfo, EVT_WARNING, "      - truncating segment to %d\n", seg->newlen);
+					break;
+				};
+
+#endif /* USE_JPWL */
+				
+				cblk->data = (unsigned char*) opj_realloc(cblk->data, (cblk->len + seg->newlen) * sizeof(unsigned char));
+				memcpy(cblk->data + cblk->len, c, seg->newlen);
+				if (seg->numpasses == 0) {
+					seg->data = &cblk->data;
+					seg->dataindex = cblk->len;
+				}
+				c += seg->newlen;
+				cblk->len += seg->newlen;
+				seg->len += seg->newlen;
+				seg->numpasses += seg->numnewpasses;
+				cblk->numnewpasses -= seg->numnewpasses;
+				if (cblk->numnewpasses > 0) {
+					seg++;
+					cblk->numsegs++;
+				}
+			} while (cblk->numnewpasses > 0);
+		}
+	}
+	
+	return (c - src);
+}
+
+/* ----------------------------------------------------------------------- */
+
+int t2_encode_packets(opj_t2_t* t2,int tileno, opj_tcd_tile_t *tile, int maxlayers, unsigned char *dest, int len, opj_codestream_info_t *cstr_info,int tpnum, int tppos,int pino, J2K_T2_MODE t2_mode, int cur_totnum_tp){
+	unsigned char *c = dest;
+	int e = 0;
+	int compno;
+	opj_pi_iterator_t *pi = NULL;
+	int poc;
+	opj_image_t *image = t2->image;
+	opj_cp_t *cp = t2->cp;
+	opj_tcp_t *tcp = &cp->tcps[tileno];
+	int pocno = cp->cinema == CINEMA4K_24? 2: 1;
+	int maxcomp = cp->max_comp_size > 0 ? image->numcomps : 1;
+	
+	pi = pi_initialise_encode(image, cp, tileno, t2_mode);
+	if(!pi) {
+		/* TODO: throw an error */
+		return -999;
+	}
+	
+	if(t2_mode == THRESH_CALC ){ /* Calculating threshold */
+		for(compno = 0; compno < maxcomp; compno++ ){
+			for(poc = 0; poc < pocno ; poc++){
+				int comp_len = 0;
+				int tpnum = compno;
+				if (pi_create_encode(pi, cp,tileno,poc,tpnum,tppos,t2_mode,cur_totnum_tp)) {
+					opj_event_msg(t2->cinfo, EVT_ERROR, "Error initializing Packet Iterator\n");
+					pi_destroy(pi, cp, tileno);
+					return -999;
+				}
+				while (pi_next(&pi[poc])) {
+					if (pi[poc].layno < maxlayers) {
+						e = t2_encode_packet(tile, &cp->tcps[tileno], &pi[poc], c, dest + len - c, cstr_info, tileno);
+						comp_len = comp_len + e;
+						if (e == -999) {
+							break;
+						} else {
+							c += e;
+						}
+					}
+				}
+				if (e == -999) break;
+				if (cp->max_comp_size){
+					if (comp_len > cp->max_comp_size){
+						e = -999;
+						break;
+					}
+				}
+			}
+			if (e == -999)  break;
+		}
+	}else{  /* t2_mode == FINAL_PASS  */
+		pi_create_encode(pi, cp,tileno,pino,tpnum,tppos,t2_mode,cur_totnum_tp);
+		while (pi_next(&pi[pino])) {
+			if (pi[pino].layno < maxlayers) {
+				e = t2_encode_packet(tile, &cp->tcps[tileno], &pi[pino], c, dest + len - c, cstr_info, tileno);
+				if (e == -999) {
+					break;
+				} else {
+					c += e;
+				}
+				/* INDEX >> */
+				if(cstr_info) {
+					if(cstr_info->index_write) {
+						opj_tile_info_t *info_TL = &cstr_info->tile[tileno];
+						opj_packet_info_t *info_PK = &info_TL->packet[cstr_info->packno];
+						if (!cstr_info->packno) {
+							info_PK->start_pos = info_TL->end_header + 1;
+						} else {
+							info_PK->start_pos = ((cp->tp_on | tcp->POC)&& info_PK->start_pos) ? info_PK->start_pos : info_TL->packet[cstr_info->packno - 1].end_pos + 1;
+						}
+						info_PK->end_pos = info_PK->start_pos + e - 1;
+						info_PK->end_ph_pos += info_PK->start_pos - 1;	/* End of packet header which now only represents the distance 
+																														// to start of packet is incremented by value of start of packet*/
+					}
+					
+					cstr_info->packno++;
+				}
+				/* << INDEX */
+				tile->packno++;
+			}
+		}
+	}
+	
+	pi_destroy(pi, cp, tileno);
+	
+	if (e == -999) {
+		return e;
+	}
+	
+  return (c - dest);
+}
+
+int t2_decode_packets(opj_t2_t *t2, unsigned char *src, int len, int tileno, opj_tcd_tile_t *tile, opj_codestream_info_t *cstr_info) {
+	unsigned char *c = src;
+	opj_pi_iterator_t *pi;
+	int pino, e = 0;
+	int n = 0, curtp = 0;
+	int tp_start_packno;
+
+	opj_image_t *image = t2->image;
+	opj_cp_t *cp = t2->cp;
+	
+	/* create a packet iterator */
+	pi = pi_create_decode(image, cp, tileno);
+	if(!pi) {
+		/* TODO: throw an error */
+		return -999;
+	}
+
+	tp_start_packno = 0;
+	
+	for (pino = 0; pino <= cp->tcps[tileno].numpocs; pino++) {
+		while (pi_next(&pi[pino])) {
+			if ((cp->layer==0) || (cp->layer>=((pi[pino].layno)+1))) {
+				opj_packet_info_t *pack_info;
+				if (cstr_info)
+					pack_info = &cstr_info->tile[tileno].packet[cstr_info->packno];
+				else
+					pack_info = NULL;
+				e = t2_decode_packet(t2, c, src + len - c, tile, &cp->tcps[tileno], &pi[pino], pack_info);
+			} else {
+				e = 0;
+			}
+            if(e == -999)
+            {
+                pi_destroy(pi, cp, tileno);
+                return -999;
+            }
+			/* progression in resolution */
+			image->comps[pi[pino].compno].resno_decoded =	
+				(e > 0) ? 
+				int_max(pi[pino].resno, image->comps[pi[pino].compno].resno_decoded) 
+				: image->comps[pi[pino].compno].resno_decoded;
+			n++;
+
+			/* INDEX >> */
+			if(cstr_info) {
+				opj_tile_info_t *info_TL = &cstr_info->tile[tileno];
+				opj_packet_info_t *info_PK = &info_TL->packet[cstr_info->packno];
+				if (!cstr_info->packno) {
+					info_PK->start_pos = info_TL->end_header + 1;
+				} else if (info_TL->packet[cstr_info->packno-1].end_pos >= (int)cstr_info->tile[tileno].tp[curtp].tp_end_pos){ /* New tile part*/
+					info_TL->tp[curtp].tp_numpacks = cstr_info->packno - tp_start_packno; /* Number of packets in previous tile-part*/
+          info_TL->tp[curtp].tp_start_pack = tp_start_packno;
+					tp_start_packno = cstr_info->packno;
+					curtp++;
+					info_PK->start_pos = cstr_info->tile[tileno].tp[curtp].tp_end_header+1;
+				} else {
+					info_PK->start_pos = (cp->tp_on && info_PK->start_pos) ? info_PK->start_pos : info_TL->packet[cstr_info->packno - 1].end_pos + 1;
+				}
+				info_PK->end_pos = info_PK->start_pos + e - 1;
+				info_PK->end_ph_pos += info_PK->start_pos - 1;	/* End of packet header which now only represents the distance 
+																												// to start of packet is incremented by value of start of packet*/
+				cstr_info->packno++;
+			}
+			/* << INDEX */
+			
+			if (e == -999) {		/* ADD */
+				break;
+			} else {
+				c += e;
+			}			
+		}
+	}
+	/* INDEX >> */
+	if(cstr_info) {
+		cstr_info->tile[tileno].tp[curtp].tp_numpacks = cstr_info->packno - tp_start_packno; /* Number of packets in last tile-part*/
+    cstr_info->tile[tileno].tp[curtp].tp_start_pack = tp_start_packno;
+	}
+	/* << INDEX */
+
+	/* don't forget to release pi */
+	pi_destroy(pi, cp, tileno);
+	
+	if (e == -999) {
+		return e;
+	}
+	
+	return (c - src);
+}
+
+/* ----------------------------------------------------------------------- */
+
+opj_t2_t* t2_create(opj_common_ptr cinfo, opj_image_t *image, opj_cp_t *cp) {
+	/* create the tcd structure */
+	opj_t2_t *t2 = (opj_t2_t*)opj_malloc(sizeof(opj_t2_t));
+	if(!t2) return NULL;
+	t2->cinfo = cinfo;
+	t2->image = image;
+	t2->cp = cp;
+
+	return t2;
+}
+
+void t2_destroy(opj_t2_t *t2) {
+	if(t2) {
+		opj_free(t2);
+	}
+}
+
+
+
+
+

src/add-ons/translators/icns/openjpeg/t2.h

@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __T2_H
+#define __T2_H
+/**
+@file t2.h
+@brief Implementation of a tier-2 coding (packetization of code-block data) (T2)
+
+*/
+
+/** @defgroup T2 T2 - Implementation of a tier-2 coding */
+/*@{*/
+
+/**
+Tier-2 coding
+*/
+typedef struct opj_t2 {
+	/** codec context */
+	opj_common_ptr cinfo;
+
+	/** Encoding: pointer to the src image. Decoding: pointer to the dst image. */
+	opj_image_t *image;
+	/** pointer to the image coding parameters */
+	opj_cp_t *cp;
+} opj_t2_t;
+
+/** @name Exported functions */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+
+/**
+Encode the packets of a tile to a destination buffer
+@param t2 T2 handle
+@param tileno number of the tile encoded
+@param tile the tile for which to write the packets
+@param maxlayers maximum number of layers
+@param dest the destination buffer
+@param len the length of the destination buffer
+@param cstr_info Codestream information structure 
+@param tpnum Tile part number of the current tile
+@param tppos The position of the tile part flag in the progression order
+@param pino 
+@param t2_mode If == 0 In Threshold calculation ,If == 1 Final pass
+@param cur_totnum_tp The total number of tile parts in the current tile
+*/
+int t2_encode_packets(opj_t2_t* t2,int tileno, opj_tcd_tile_t *tile, int maxlayers, unsigned char *dest, int len, opj_codestream_info_t *cstr_info,int tpnum, int tppos,int pino,J2K_T2_MODE t2_mode,int cur_totnum_tp);
+/**
+Decode the packets of a tile from a source buffer
+@param t2 T2 handle
+@param src the source buffer
+@param len length of the source buffer
+@param tileno number that identifies the tile for which to decode the packets
+@param tile tile for which to decode the packets
+@param cstr_info Codestream information structure
+ */
+int t2_decode_packets(opj_t2_t *t2, unsigned char *src, int len, int tileno, opj_tcd_tile_t *tile, opj_codestream_info_t *cstr_info);
+
+/**
+Create a T2 handle
+@param cinfo Codec context info
+@param image Source or destination image
+@param cp Image coding parameters
+@return Returns a new T2 handle if successful, returns NULL otherwise
+*/
+opj_t2_t* t2_create(opj_common_ptr cinfo, opj_image_t *image, opj_cp_t *cp);
+/**
+Destroy a T2 handle
+@param t2 T2 handle to destroy
+*/
+void t2_destroy(opj_t2_t *t2);
+
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __T2_H */

src/add-ons/translators/icns/openjpeg/tcd.h

@@ -0,0 +1,286 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __TCD_H
+#define __TCD_H
+/**
+@file tcd.h
+@brief Implementation of a tile coder/decoder (TCD)
+
+The functions in TCD.C have for goal to encode or decode each tile independently from
+each other. The functions in TCD.C are used by some function in J2K.C.
+*/
+
+/** @defgroup TCD TCD - Implementation of a tile coder/decoder */
+/*@{*/
+
+/**
+FIXME: documentation
+*/
+typedef struct opj_tcd_seg {
+  unsigned char** data;
+  int dataindex;
+  int numpasses;
+  int len;
+  int maxpasses;
+  int numnewpasses;
+  int newlen;
+} opj_tcd_seg_t;
+
+/**
+FIXME: documentation
+*/
+typedef struct opj_tcd_pass {
+  int rate;
+  double distortiondec;
+  int term, len;
+} opj_tcd_pass_t;
+
+/**
+FIXME: documentation
+*/
+typedef struct opj_tcd_layer {
+  int numpasses;		/* Number of passes in the layer */
+  int len;			/* len of information */
+  double disto;			/* add for index (Cfr. Marcela) */
+  unsigned char *data;		/* data */
+} opj_tcd_layer_t;
+
+/**
+FIXME: documentation
+*/
+typedef struct opj_tcd_cblk_enc {
+  unsigned char* data;	/* Data */
+  opj_tcd_layer_t* layers;	/* layer information */
+  opj_tcd_pass_t* passes;	/* information about the passes */
+  int x0, y0, x1, y1;		/* dimension of the code-blocks : left upper corner (x0, y0) right low corner (x1,y1) */
+  int numbps;
+  int numlenbits;
+  int numpasses;		/* number of pass already done for the code-blocks */
+  int numpassesinlayers;	/* number of passes in the layer */
+  int totalpasses;		/* total number of passes */
+} opj_tcd_cblk_enc_t;
+
+typedef struct opj_tcd_cblk_dec {
+  unsigned char* data;	/* Data */
+  opj_tcd_seg_t* segs;		/* segments informations */
+	int x0, y0, x1, y1;		/* dimension of the code-blocks : left upper corner (x0, y0) right low corner (x1,y1) */
+  int numbps;
+  int numlenbits;
+  int len;			/* length */
+  int numnewpasses;		/* number of pass added to the code-blocks */
+  int numsegs;			/* number of segments */
+} opj_tcd_cblk_dec_t;
+
+/**
+FIXME: documentation
+*/
+typedef struct opj_tcd_precinct {
+  int x0, y0, x1, y1;		/* dimension of the precinct : left upper corner (x0, y0) right low corner (x1,y1) */
+  int cw, ch;			/* number of precinct in width and heigth */
+  union{		/* code-blocks informations */
+	  opj_tcd_cblk_enc_t* enc;
+	  opj_tcd_cblk_dec_t* dec;
+  } cblks;
+  opj_tgt_tree_t *incltree;		/* inclusion tree */
+  opj_tgt_tree_t *imsbtree;		/* IMSB tree */
+} opj_tcd_precinct_t;
+
+/**
+FIXME: documentation
+*/
+typedef struct opj_tcd_band {
+  int x0, y0, x1, y1;		/* dimension of the subband : left upper corner (x0, y0) right low corner (x1,y1) */
+  int bandno;
+  opj_tcd_precinct_t *precincts;	/* precinct information */
+  int numbps;
+  float stepsize;
+} opj_tcd_band_t;
+
+/**
+FIXME: documentation
+*/
+typedef struct opj_tcd_resolution {
+  int x0, y0, x1, y1;		/* dimension of the resolution level : left upper corner (x0, y0) right low corner (x1,y1) */
+  int pw, ph;
+  int numbands;			/* number sub-band for the resolution level */
+  opj_tcd_band_t bands[3];		/* subband information */
+} opj_tcd_resolution_t;
+
+/**
+FIXME: documentation
+*/
+typedef struct opj_tcd_tilecomp {
+  int x0, y0, x1, y1;		/* dimension of component : left upper corner (x0, y0) right low corner (x1,y1) */
+  int numresolutions;		/* number of resolutions level */
+  opj_tcd_resolution_t *resolutions;	/* resolutions information */
+  int *data;			/* data of the component */
+  int numpix;			/* add fixed_quality */
+} opj_tcd_tilecomp_t;
+
+/**
+FIXME: documentation
+*/
+typedef struct opj_tcd_tile {
+  int x0, y0, x1, y1;		/* dimension of the tile : left upper corner (x0, y0) right low corner (x1,y1) */
+  int numcomps;			/* number of components in tile */
+  opj_tcd_tilecomp_t *comps;	/* Components information */
+  int numpix;			/* add fixed_quality */
+  double distotile;		/* add fixed_quality */
+  double distolayer[100];	/* add fixed_quality */
+  /** packet number */
+  int packno;
+} opj_tcd_tile_t;
+
+/**
+FIXME: documentation
+*/
+typedef struct opj_tcd_image {
+  int tw, th;			/* number of tiles in width and heigth */
+  opj_tcd_tile_t *tiles;		/* Tiles information */
+} opj_tcd_image_t;
+
+/**
+Tile coder/decoder
+*/
+typedef struct opj_tcd {
+	/** Position of the tilepart flag in Progression order*/
+	int tp_pos;
+	/** Tile part number*/
+	int tp_num;
+	/** Current tile part number*/
+	int cur_tp_num;
+	/** Total number of tileparts of the current tile*/
+	int cur_totnum_tp;
+	/** Current Packet iterator number */
+	int cur_pino;
+	/** codec context */
+	opj_common_ptr cinfo;
+
+	/** info on each image tile */
+	opj_tcd_image_t *tcd_image;
+	/** image */
+	opj_image_t *image;
+	/** coding parameters */
+	opj_cp_t *cp;
+	/** pointer to the current encoded/decoded tile */
+	opj_tcd_tile_t *tcd_tile;
+	/** coding/decoding parameters common to all tiles */
+	opj_tcp_t *tcp;
+	/** current encoded/decoded tile */
+	int tcd_tileno;
+	/** Time taken to encode a tile*/
+	double encoding_time;
+} opj_tcd_t;
+
+/** @name Exported functions */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+
+/**
+Dump the content of a tcd structure
+*/
+void tcd_dump(FILE *fd, opj_tcd_t *tcd, opj_tcd_image_t *img);
+/**
+Create a new TCD handle
+@param cinfo Codec context info
+@return Returns a new TCD handle if successful returns NULL otherwise
+*/
+opj_tcd_t* tcd_create(opj_common_ptr cinfo);
+/**
+Destroy a previously created TCD handle
+@param tcd TCD handle to destroy
+*/
+void tcd_destroy(opj_tcd_t *tcd);
+/**
+Initialize the tile coder (allocate the memory)
+@param tcd TCD handle
+@param image Raw image
+@param cp Coding parameters
+@param curtileno Number that identifies the tile that will be encoded
+*/
+void tcd_malloc_encode(opj_tcd_t *tcd, opj_image_t * image, opj_cp_t * cp, int curtileno);
+/**
+Free the memory allocated for encoding
+@param tcd TCD handle
+*/
+void tcd_free_encode(opj_tcd_t *tcd);
+/**
+Initialize the tile coder (reuses the memory allocated by tcd_malloc_encode)
+@param tcd TCD handle
+@param image Raw image
+@param cp Coding parameters
+@param curtileno Number that identifies the tile that will be encoded
+*/
+void tcd_init_encode(opj_tcd_t *tcd, opj_image_t * image, opj_cp_t * cp, int curtileno);
+/**
+Initialize the tile decoder
+@param tcd TCD handle
+@param image Raw image
+@param cp Coding parameters
+*/
+void tcd_malloc_decode(opj_tcd_t *tcd, opj_image_t * image, opj_cp_t * cp);
+void tcd_malloc_decode_tile(opj_tcd_t *tcd, opj_image_t * image, opj_cp_t * cp, int tileno, opj_codestream_info_t *cstr_info);
+void tcd_makelayer_fixed(opj_tcd_t *tcd, int layno, int final);
+void tcd_rateallocate_fixed(opj_tcd_t *tcd);
+void tcd_makelayer(opj_tcd_t *tcd, int layno, double thresh, int final);
+opj_bool tcd_rateallocate(opj_tcd_t *tcd, unsigned char *dest, int len, opj_codestream_info_t *cstr_info);
+/**
+Encode a tile from the raw image into a buffer
+@param tcd TCD handle
+@param tileno Number that identifies one of the tiles to be encoded
+@param dest Destination buffer
+@param len Length of destination buffer
+@param cstr_info Codestream information structure 
+@return 
+*/
+int tcd_encode_tile(opj_tcd_t *tcd, int tileno, unsigned char *dest, int len, opj_codestream_info_t *cstr_info);
+/**
+Decode a tile from a buffer into a raw image
+@param tcd TCD handle
+@param src Source buffer
+@param len Length of source buffer
+@param tileno Number that identifies one of the tiles to be decoded
+@param cstr_info Codestream information structure
+*/
+opj_bool tcd_decode_tile(opj_tcd_t *tcd, unsigned char *src, int len, int tileno, opj_codestream_info_t *cstr_info);
+/**
+Free the memory allocated for decoding
+@param tcd TCD handle
+*/
+void tcd_free_decode(opj_tcd_t *tcd);
+void tcd_free_decode_tile(opj_tcd_t *tcd, int tileno);
+
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __TCD_H */

src/add-ons/translators/icns/openjpeg/tgt.c

@@ -0,0 +1,213 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "opj_includes.h"
+
+/* 
+==========================================================
+   Tag-tree coder interface
+==========================================================
+*/
+
+opj_tgt_tree_t *tgt_create(int numleafsh, int numleafsv) {
+	int nplh[32];
+	int nplv[32];
+	opj_tgt_node_t *node = NULL;
+	opj_tgt_node_t *parentnode = NULL;
+	opj_tgt_node_t *parentnode0 = NULL;
+	opj_tgt_tree_t *tree = NULL;
+	int i, j, k;
+	int numlvls;
+	int n;
+
+	tree = (opj_tgt_tree_t *) opj_malloc(sizeof(opj_tgt_tree_t));
+	if(!tree) return NULL;
+	tree->numleafsh = numleafsh;
+	tree->numleafsv = numleafsv;
+
+	numlvls = 0;
+	nplh[0] = numleafsh;
+	nplv[0] = numleafsv;
+	tree->numnodes = 0;
+	do {
+		n = nplh[numlvls] * nplv[numlvls];
+		nplh[numlvls + 1] = (nplh[numlvls] + 1) / 2;
+		nplv[numlvls + 1] = (nplv[numlvls] + 1) / 2;
+		tree->numnodes += n;
+		++numlvls;
+	} while (n > 1);
+	
+	/* ADD */
+	if (tree->numnodes == 0) {
+		opj_free(tree);
+		return NULL;
+	}
+
+	tree->nodes = (opj_tgt_node_t*) opj_calloc(tree->numnodes, sizeof(opj_tgt_node_t));
+	if(!tree->nodes) {
+		opj_free(tree);
+		return NULL;
+	}
+
+	node = tree->nodes;
+	parentnode = &tree->nodes[tree->numleafsh * tree->numleafsv];
+	parentnode0 = parentnode;
+	
+	for (i = 0; i < numlvls - 1; ++i) {
+		for (j = 0; j < nplv[i]; ++j) {
+			k = nplh[i];
+			while (--k >= 0) {
+				node->parent = parentnode;
+				++node;
+				if (--k >= 0) {
+					node->parent = parentnode;
+					++node;
+				}
+				++parentnode;
+			}
+			if ((j & 1) || j == nplv[i] - 1) {
+				parentnode0 = parentnode;
+			} else {
+				parentnode = parentnode0;
+				parentnode0 += nplh[i];
+			}
+		}
+	}
+	node->parent = 0;
+	
+	tgt_reset(tree);
+	
+	return tree;
+}
+
+void tgt_destroy(opj_tgt_tree_t *tree) {
+	opj_free(tree->nodes);
+	opj_free(tree);
+}
+
+void tgt_reset(opj_tgt_tree_t *tree) {
+	int i;
+
+	if (NULL == tree)
+		return;
+	
+	for (i = 0; i < tree->numnodes; i++) {
+		tree->nodes[i].value = 999;
+		tree->nodes[i].low = 0;
+		tree->nodes[i].known = 0;
+	}
+}
+
+void tgt_setvalue(opj_tgt_tree_t *tree, int leafno, int value) {
+	opj_tgt_node_t *node;
+	node = &tree->nodes[leafno];
+	while (node && node->value > value) {
+		node->value = value;
+		node = node->parent;
+	}
+}
+
+void tgt_encode(opj_bio_t *bio, opj_tgt_tree_t *tree, int leafno, int threshold) {
+	opj_tgt_node_t *stk[31];
+	opj_tgt_node_t **stkptr;
+	opj_tgt_node_t *node;
+	int low;
+
+	stkptr = stk;
+	node = &tree->nodes[leafno];
+	while (node->parent) {
+		*stkptr++ = node;
+		node = node->parent;
+	}
+	
+	low = 0;
+	for (;;) {
+		if (low > node->low) {
+			node->low = low;
+		} else {
+			low = node->low;
+		}
+		
+		while (low < threshold) {
+			if (low >= node->value) {
+				if (!node->known) {
+					bio_write(bio, 1, 1);
+					node->known = 1;
+				}
+				break;
+			}
+			bio_write(bio, 0, 1);
+			++low;
+		}
+		
+		node->low = low;
+		if (stkptr == stk)
+			break;
+		node = *--stkptr;
+	}
+}
+
+int tgt_decode(opj_bio_t *bio, opj_tgt_tree_t *tree, int leafno, int threshold) {
+	opj_tgt_node_t *stk[31];
+	opj_tgt_node_t **stkptr;
+	opj_tgt_node_t *node;
+	int low;
+
+	stkptr = stk;
+	node = &tree->nodes[leafno];
+	while (node->parent) {
+		*stkptr++ = node;
+		node = node->parent;
+	}
+	
+	low = 0;
+	for (;;) {
+		if (low > node->low) {
+			node->low = low;
+		} else {
+			low = node->low;
+		}
+		while (low < threshold && low < node->value) {
+			if (bio_read(bio, 1)) {
+				node->value = low;
+			} else {
+				++low;
+			}
+		}
+		node->low = low;
+		if (stkptr == stk) {
+			break;
+		}
+		node = *--stkptr;
+	}
+	
+	return (node->value < threshold) ? 1 : 0;
+}

src/add-ons/translators/icns/openjpeg/tgt.h

@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __TGT_H
+#define __TGT_H
+/**
+@file tgt.h
+@brief Implementation of a tag-tree coder (TGT)
+
+The functions in TGT.C have for goal to realize a tag-tree coder. The functions in TGT.C
+are used by some function in T2.C.
+*/
+
+/** @defgroup TGT TGT - Implementation of a tag-tree coder */
+/*@{*/
+
+/**
+Tag node
+*/
+typedef struct opj_tgt_node {
+  struct opj_tgt_node *parent;
+  int value;
+  int low;
+  int known;
+} opj_tgt_node_t;
+
+/**
+Tag tree
+*/
+typedef struct opj_tgt_tree {
+  int numleafsh;
+  int numleafsv;
+  int numnodes;
+  opj_tgt_node_t *nodes;
+} opj_tgt_tree_t;
+
+/** @name Exported functions */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+/**
+Create a tag-tree
+@param numleafsh Width of the array of leafs of the tree
+@param numleafsv Height of the array of leafs of the tree
+@return Returns a new tag-tree if successful, returns NULL otherwise
+*/
+opj_tgt_tree_t *tgt_create(int numleafsh, int numleafsv);
+/**
+Destroy a tag-tree, liberating memory
+@param tree Tag-tree to destroy
+*/
+void tgt_destroy(opj_tgt_tree_t *tree);
+/**
+Reset a tag-tree (set all leaves to 0)
+@param tree Tag-tree to reset
+*/
+void tgt_reset(opj_tgt_tree_t *tree);
+/**
+Set the value of a leaf of a tag-tree
+@param tree Tag-tree to modify
+@param leafno Number that identifies the leaf to modify
+@param value New value of the leaf
+*/
+void tgt_setvalue(opj_tgt_tree_t *tree, int leafno, int value);
+/**
+Encode the value of a leaf of the tag-tree up to a given threshold
+@param bio Pointer to a BIO handle
+@param tree Tag-tree to modify
+@param leafno Number that identifies the leaf to encode
+@param threshold Threshold to use when encoding value of the leaf
+*/
+void tgt_encode(opj_bio_t *bio, opj_tgt_tree_t *tree, int leafno, int threshold);
+/**
+Decode the value of a leaf of the tag-tree up to a given threshold
+@param bio Pointer to a BIO handle
+@param tree Tag-tree to decode
+@param leafno Number that identifies the leaf to decode
+@param threshold Threshold to use when decoding value of the leaf
+@return Returns 1 if the node's value < threshold, returns 0 otherwise
+*/
+int tgt_decode(opj_bio_t *bio, opj_tgt_tree_t *tree, int leafno, int threshold);
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __TGT_H */

src/add-ons/translators/icns/openjpeg/thix_manager.c

@@ -0,0 +1,120 @@
+/*
+ * $Id: thix_manager.c 897 2011-08-28 21:43:57Z Kaori.Hagihara@gmail.com $
+ *
+ * Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2011, Professor Benoit Macq
+ * Copyright (c) 2003-2004, Yannick Verschueren
+ * Copyright (c) 2010-2011, Kaori Hagihara
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*! \file
+ *  \brief Modification of jpip.c from 2KAN indexer
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include "opj_includes.h"
+
+/* 
+ * Write tile-part headers mhix box
+ *
+ * @param[in] coff      offset of j2k codestream
+ * @param[in] cstr_info codestream information
+ * @param[in] tileno    tile number
+ * @param[in] cio       file output handle
+ * @return              length of mhix box
+ */
+int write_tilemhix( int coff, opj_codestream_info_t cstr_info, int tileno, opj_cio_t *cio);
+
+int write_thix( int coff, opj_codestream_info_t cstr_info, opj_cio_t *cio)
+{
+  int len, lenp, i;
+  int tileno;
+  opj_jp2_box_t *box;
+
+  lenp = 0;
+  box = (opj_jp2_box_t *)opj_calloc( cstr_info.tw*cstr_info.th, sizeof(opj_jp2_box_t));
+
+  for ( i = 0; i < 2 ; i++ ){
+    if (i)
+      cio_seek( cio, lenp);
+
+    lenp = cio_tell( cio);
+    cio_skip( cio, 4);              /* L [at the end] */
+    cio_write( cio, JPIP_THIX, 4);  /* THIX           */
+    write_manf( i, cstr_info.tw*cstr_info.th, box, cio);
+    
+    for (tileno = 0; tileno < cstr_info.tw*cstr_info.th; tileno++){
+      box[tileno].length = write_tilemhix( coff, cstr_info, tileno, cio);
+      box[tileno].type = JPIP_MHIX;
+    }
+ 
+    len = cio_tell( cio)-lenp;
+    cio_seek( cio, lenp);
+    cio_write( cio, len, 4);        /* L              */
+    cio_seek( cio, lenp+len);
+  }
+
+  opj_free(box);
+
+  return len;
+}
+
+int write_tilemhix( int coff, opj_codestream_info_t cstr_info, int tileno, opj_cio_t *cio)
+{
+  int i;
+  opj_tile_info_t tile;
+  opj_tp_info_t tp;
+  int len, lenp;
+  opj_marker_info_t *marker;
+
+  lenp = cio_tell( cio);
+  cio_skip( cio, 4);                               /* L [at the end]                    */
+  cio_write( cio, JPIP_MHIX, 4);                   /* MHIX                              */
+
+  tile = cstr_info.tile[tileno];
+  tp = tile.tp[0];
+
+  cio_write( cio, tp.tp_end_header-tp.tp_start_pos+1, 8);  /* TLEN                              */ 
+
+  marker = cstr_info.tile[tileno].marker;
+
+  for( i=0; i<cstr_info.tile[tileno].marknum; i++){             /* Marker restricted to 1 apparition */
+    cio_write( cio, marker[i].type, 2);
+    cio_write( cio, 0, 2);
+    cio_write( cio, marker[i].pos-coff, 8);
+    cio_write( cio, marker[i].len, 2);
+  }
+     
+  /*  free( marker);*/
+
+  len = cio_tell( cio) - lenp;
+  cio_seek( cio, lenp);
+  cio_write( cio, len, 4);        /* L           */
+  cio_seek( cio, lenp+len);
+
+  return len;
+}

src/add-ons/translators/icns/openjpeg/tpix_manager.c

@@ -0,0 +1,153 @@
+/*
+ * $Id: tpix_manager.c 897 2011-08-28 21:43:57Z Kaori.Hagihara@gmail.com $
+ *
+ * Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2011, Professor Benoit Macq
+ * Copyright (c) 2003-2004, Yannick Verschueren
+ * Copyright (c) 2010-2011, Kaori Hagihara
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*! \file
+ *  \brief Modification of jpip.c from 2KAN indexer
+ */
+
+#include <math.h>
+#include "opj_includes.h"
+
+#define MAX(a,b) ((a)>(b)?(a):(b))
+
+
+/* 
+ * Write faix box of tpix
+ *
+ * @param[in] coff offset of j2k codestream
+ * @param[in] compno    component number
+ * @param[in] cstr_info codestream information
+ * @param[in] j2klen    length of j2k codestream
+ * @param[in] cio       file output handle
+ * @return              length of faix box
+ */
+int write_tpixfaix( int coff, int compno, opj_codestream_info_t cstr_info, int j2klen, opj_cio_t *cio);
+
+
+int write_tpix( int coff, opj_codestream_info_t cstr_info, int j2klen, opj_cio_t *cio)
+{
+  int len, lenp;
+  lenp = cio_tell( cio);
+  cio_skip( cio, 4);              /* L [at the end] */
+  cio_write( cio, JPIP_TPIX, 4);  /* TPIX           */
+  
+  write_tpixfaix( coff, 0, cstr_info, j2klen, cio);
+
+  len = cio_tell( cio)-lenp;
+  cio_seek( cio, lenp);
+  cio_write( cio, len, 4);        /* L              */
+  cio_seek( cio, lenp+len);
+
+  return len;
+}
+
+
+/* 
+ * Get number of maximum tile parts per tile
+ *
+ * @param[in] cstr_info codestream information
+ * @return              number of maximum tile parts per tile
+ */
+int get_num_max_tile_parts( opj_codestream_info_t cstr_info);
+
+int write_tpixfaix( int coff, int compno, opj_codestream_info_t cstr_info, int j2klen, opj_cio_t *cio)
+{
+  int len, lenp;
+  int i, j;
+  int Aux;
+  int num_max_tile_parts;
+  int size_of_coding; /* 4 or 8 */
+  opj_tp_info_t tp;
+  int version;
+
+  num_max_tile_parts = get_num_max_tile_parts( cstr_info);
+
+  if( j2klen > pow( 2, 32)){
+    size_of_coding =  8;
+    version = num_max_tile_parts == 1 ? 1:3;
+  }
+  else{
+    size_of_coding = 4;
+    version = num_max_tile_parts == 1 ? 0:2;
+  }
+
+  lenp = cio_tell( cio);
+  cio_skip( cio, 4);              /* L [at the end]      */
+  cio_write( cio, JPIP_FAIX, 4);  /* FAIX                */ 
+  cio_write( cio, version, 1);     /* Version 0 = 4 bytes */
+
+  cio_write( cio, num_max_tile_parts, size_of_coding);                      /* NMAX           */
+  cio_write( cio, cstr_info.tw*cstr_info.th, size_of_coding);                               /* M              */
+  for (i = 0; i < cstr_info.tw*cstr_info.th; i++){
+    for (j = 0; j < cstr_info.tile[i].num_tps; j++){
+      tp = cstr_info.tile[i].tp[j];
+      cio_write( cio, tp.tp_start_pos-coff, size_of_coding); /* start position */
+      cio_write( cio, tp.tp_end_pos-tp.tp_start_pos+1, size_of_coding);    /* length         */
+      if (version & 0x02){
+	if( cstr_info.tile[i].num_tps == 1 && cstr_info.numdecompos[compno] > 1)
+	  Aux = cstr_info.numdecompos[compno] + 1;
+	else
+	  Aux = j + 1;
+		  
+	cio_write( cio, Aux,4);
+	/*cio_write(img.tile[i].tile_parts[j].num_reso_AUX,4);*/ /* Aux_i,j : Auxiliary value */
+	/* fprintf(stderr,"AUX value %d\n",Aux);*/
+      }
+      /*cio_write(0,4);*/
+    }
+    /* PADDING */
+    while (j < num_max_tile_parts){
+      cio_write( cio, 0, size_of_coding); /* start position            */
+      cio_write( cio, 0, size_of_coding); /* length                    */
+      if (version & 0x02)
+	cio_write( cio, 0,4);                  /* Aux_i,j : Auxiliary value */
+      j++;
+    }
+  }
+  
+  len = cio_tell( cio)-lenp;
+  cio_seek( cio, lenp);
+  cio_write( cio, len, 4);        /* L  */
+  cio_seek( cio, lenp+len);
+
+  return len;
+
+}
+
+int get_num_max_tile_parts( opj_codestream_info_t cstr_info)
+{
+  int num_max_tp = 0, i;
+
+  for( i=0; i<cstr_info.tw*cstr_info.th; i++)
+    num_max_tp = MAX( cstr_info.tile[i].num_tps, num_max_tp);
+  
+  return num_max_tp;
+}

src/data/beos_mime/image/icns

@@ -0,0 +1,13 @@
+
+resource(0, "BEOS:TYPE") #'MIMS' "application/x-vnd.Be-meta-mime";
+
+resource(1, "META:TYPE") "image/icns";
+
+resource(2, "META:SNIFF_RULE") "0.50 (\"icns\")";
+
+resource(3, "META:S:DESC") #'MSDC' "Apple icon";
+
+resource(4, "META:EXTENS") message(234) {
+	"extensions" = "icns",
+	"type" = "image/icns"
+};

src/system/kernel/vm/vm_page.cpp

@@ -3831,8 +3831,8 @@ vm_page_allocate_page_run(uint32 flags, page_num_t length,
 	ASSERT(((alignmentMask + 1) & alignmentMask) == 0);
 		// alignment must be a power of 2
 
-	// compute the boundary shift
+	// compute the boundary mask
-	uint32 boundaryShift = 0;
+	uint32 boundaryMask = 0;
 	if (restrictions->boundary != 0) {
 		page_num_t boundary = restrictions->boundary / B_PAGE_SIZE;
 		// boundary must be a power of two and not less than alignment and
@@ -3841,8 +3841,7 @@ vm_page_allocate_page_run(uint32 flags, page_num_t length,
 		ASSERT(boundary >= alignmentMask + 1);
 		ASSERT(boundary >= length);
 
-		while ((boundary >>= 1) > 0)
+		boundaryMask = -boundary;
-			boundaryShift++;
 	}
 
 	vm_page_reservation reservation;
@@ -3858,19 +3857,17 @@ vm_page_allocate_page_run(uint32 flags, page_num_t length,
 	int useCached = freePages > 0 && (page_num_t)freePages > 2 * length ? 0 : 1;
 
 	for (;;) {
-		if (alignmentMask != 0 || boundaryShift != 0) {
+		if (alignmentMask != 0 || boundaryMask != 0) {
 			page_num_t offsetStart = start + sPhysicalPageOffset;
 
 			// enforce alignment
-			if ((offsetStart & alignmentMask) != 0) {
+			if ((offsetStart & alignmentMask) != 0)
 				offsetStart = (offsetStart + alignmentMask) & ~alignmentMask;
-			}
 
 			// enforce boundary
-			if (boundaryShift != 0 && offsetStart << boundaryShift
+			if (boundaryMask != 0 && ((offsetStart ^ (offsetStart 
-					!= (offsetStart + length - 1) << boundaryShift) {
+				+ length - 1)) & boundaryMask) != 0) {
-				offsetStart = (offsetStart + length - 1) << boundaryShift
+				offsetStart = (offsetStart + length - 1) & boundaryMask;
-					>> boundaryShift;
 			}
 
 			start = offsetStart - sPhysicalPageOffset;